Common Modular Design Methods in Embedded Systems

Source: Technology Makes Dreams Greater
Author: Li Xiaoyao

Concept of Modular Design

How to improve the flexibility and maintainability of embedded programming? This is believed to be a long-term learning process for us in embedded software development.

The design of embedded systems requires high flexibility and maintainability. Modular design, as an important software engineering method, can effectively improve the development efficiency, code reusability, and maintainability of embedded systems.

Modular design refers to breaking down a system into multiple independent modules, each responsible for completing specific functions. Modules communicate through well-defined interfaces, thereby reducing system complexity and improving code readability and maintainability. In embedded systems, modular design is particularly important because they often need to handle various hardware and peripherals with limited resources.

Advantages of Modular Design in Embedded Systems

1. Improved Code Reusability: By breaking down functions into independent modules, these modules can be reused in different projects, reducing the workload of redundant development.
2. Enhanced Maintainability: Modular design makes systems easier to understand and maintain. When a module has a problem, it can be debugged and repaired independently without affecting other modules.
3. Facilitates Team Collaboration: Different developers can work in parallel on different modules, improving development efficiency.
4. Increased System Scalability: New modules can be easily added to expand the system’s functionality without large-scale modifications to existing code.
5. Reduced System Complexity: Modular design breaks complex systems into simpler modules, lowering the overall complexity of the system.

Common Modular Design Methods in Embedded Systems

1. Layered Architecture

Layered architecture is a common modular design method that divides the system into multiple layers, each responsible for specific functions. A typical embedded system can be divided into the following layers:

• Hardware Abstraction Layer (HAL): Responsible for direct interaction with hardware devices, providing a unified interface for upper-layer modules to call.
• Driver Layer: Responsible for managing specific hardware devices such as sensors and actuators.
• Middleware Layer: Provides common services such as communication protocol stacks and file systems.
• Application Layer: Implements the core business logic of the system.

The advantage of layered architecture lies in the clear responsibilities between layers, making development and maintenance easier. For example, the hardware abstraction layer can shield differences between different hardware platforms, allowing upper-level code to run on various hardware platforms.

2. Component-Based Design

Component-based design decomposes the system into multiple independent components, each providing specific services. Components communicate through well-defined interfaces. Common components in embedded systems include:

• Communication Component: Responsible for handling the system’s communication functions, such as UART, SPI, I2C, etc.
• Storage Component: Responsible for managing the system’s storage functions, such as Flash, EEPROM, etc.
• Sensor Component: Responsible for collecting data from sensors.
• Control Component: Responsible for executing control algorithms, such as PID control and fuzzy control.

The advantage of component-based design is that each component can be developed and tested independently, enhancing code reusability and maintainability. For example, the communication component can be reused in different projects without redeveloping it.

3. Event-Driven Architecture

Event-driven architecture is a modular design method based on events, where various modules of the system communicate through events. When an event occurs, the relevant modules respond and perform corresponding actions. In embedded systems, event-driven architecture is commonly used in real-time systems, such as operating systems and communication systems.

The advantage of event-driven architecture is that it can improve the system’s response speed and real-time performance. For example, in an operating system, interrupt handlers can be seen as an event-driven mechanism; when a hardware interrupt occurs, the system responds immediately and executes the corresponding action.

4. State Machine Design

State machine design is a modular design method that breaks down the system’s behavior into multiple states. Each state represents a behavioral mode of the system, and transitions between states are triggered by events. In embedded systems, state machine design is commonly used in control system design, such as automatic control systems and communication protocols.

The advantage of state machine design is that it can clearly describe the system’s behavior, making it easier to understand and maintain. For example, in a communication protocol, a state machine can describe the various states of the protocol and their transition conditions, making the implementation of the protocol clearer and more reliable.

5. Object-Oriented Design

Object-oriented design is a modular design method that decomposes the system into multiple objects, each encapsulating data and methods. In embedded systems, object-oriented design can improve code reusability and maintainability. For example, hardware devices such as sensors and actuators can be abstracted as objects, with each object providing a unified operation interface.

The advantage of object-oriented design is that it can raise the abstraction level of the code, making the system easier to understand and maintain. For example, by abstracting sensors as objects, the sensor code can be reused in different projects without redeveloping it.

Implementation of Modular Design

1. Interface Design

The interface is the core of modular design; good interface design can improve the independence and reusability of modules. In embedded systems, interface design needs to consider the following aspects:

• Simplicity: Interfaces should be as simple as possible, avoiding complex parameters and return values.
• Consistency: The naming and parameters of interfaces should remain consistent, making them easy to understand and use.
• Scalability: Interfaces should have good scalability, facilitating future functional expansions.

For example, in the hardware abstraction layer, a unified interface can be defined for each hardware device, such as init(), read(), write(), etc., allowing upper-level code to access different hardware devices through a unified interface.

2. Module Partitioning

Module partitioning is key to modular design; reasonable module partitioning can improve the maintainability and scalability of the system. In embedded systems, module partitioning needs to consider the following aspects:

• Single Responsibility: Each module should ideally only be responsible for one function, avoiding functional overlap.
• High Cohesion and Low Coupling: Modules should be highly cohesive internally and have low coupling between them.
• Testability: Each module should be as independent as possible, facilitating separate testing and debugging.

For example, in a communication system, communication protocols, data parsing, and data storage can be divided into different modules, each responsible for a specific function.

3. Module Communication

Module communication is an important aspect of modular design; a good module communication mechanism can enhance the flexibility and scalability of the system. In embedded systems, common module communication mechanisms include:

• Function Calls: Module communication through function calls is simple and direct but has a higher coupling degree.
• Message Queues: Module communication through message queues is suitable for asynchronous communication scenarios.
• Event-Driven: Module communication through events is suitable for real-time systems.

For example, in an operating system, message queues can be used to implement communication between tasks, improving the system’s concurrency and real-time performance.

Below is a code example of modular design in an embedded system. This example demonstrates a simple temperature monitoring system, divided into multiple modules, each responsible for specific functions. Through modular design, the code structure is clear, easy to extend and maintain.

4. Example

System Function Description

1. Sensor Module: Reads data from the temperature sensor.
2. Control Module: Controls the switch of the fan based on temperature data.
3. Display Module: Displays temperature data on an LCD screen.
4. Communication Module: Sends temperature data to the host computer via UART.

Modular Design

1. Sensor Module (sensor.c and sensor.h)

Responsible for reading data from the temperature sensor.

// sensor.h
#ifndef SENSOR_H
#define SENSOR_H

// Initialize the sensor
void Sensor_Init(void);

// Read temperature data
float Sensor_ReadTemperature(void);

#endif // SENSOR_H

// sensor.c
#include "sensor.h"

// Simulate reading temperature sensor data
float Sensor_ReadTemperature(void) {
    // Here can be replaced with actual sensor reading code
    static float temperature = 25.0f; // Simulated temperature value
    return temperature;
}

// Initialize the sensor
void Sensor_Init(void) {
    // Initialize sensor hardware
}

2. Control Module (control.c and control.h)

Controls the switch of the fan based on temperature data.

// control.h
#ifndef CONTROL_H
#define CONTROL_H

// Initialize control module
void Control_Init(void);

// Control fan based on temperature
void Control_Update(float temperature);

#endif // CONTROL_H

// control.c
#include "control.h"
#include <stdio.h>

// Initialize control module
void Control_Init(void) {
    // Initialize fan control hardware
}

// Control fan based on temperature
void Control_Update(float temperature) {
    if (temperature > 30.0f) {
        printf("Fan: ON\n"); // Turn on the fan
    } else {
        printf("Fan: OFF\n"); // Turn off the fan
    }
}

3. Display Module (display.c and display.h)

Displays temperature data on the LCD screen.

// display.h
#ifndef DISPLAY_H
#define DISPLAY_H

// Initialize display module
void Display_Init(void);

// Display temperature data
void Display_ShowTemperature(float temperature);

#endif // DISPLAY_H

// display.c
#include "display.h"
#include <stdio.h>

// Initialize display module
void Display_Init(void) {
    // Initialize LCD screen
}

// Display temperature data
void Display_ShowTemperature(float temperature) {
    printf("LCD: Temperature = %.2f C\n", temperature); // Simulate LCD display
}
}

4. Communication Module (communication.c and communication.h)

Sends temperature data to the host computer via UART.

// communication.h
#ifndef COMMUNICATION_H
#define COMMUNICATION_H

// Initialize communication module
void Communication_Init(void);

// Send temperature data
void Communication_SendTemperature(float temperature);

#endif // COMMUNICATION_H

// communication.c
#include "communication.h"
#include <stdio.h>

// Initialize communication module
void Communication_Init(void) {
    // Initialize UART hardware
}

// Send temperature data
void Communication_SendTemperature(float temperature) {
    printf("UART: Sending temperature = %.2f C\n", temperature); // Simulate UART sending
}
}

Main Program (main.c)

Integrates all modules to implement a complete temperature monitoring system.

#include "sensor.h"
#include "control.h"
#include "display.h"
#include "communication.h"
#include <unistd.h> // For sleep function

int main(void) {
    // Initialize all modules
    Sensor_Init();
    Control_Init();
    Display_Init();
    Communication_Init();

    while (1) {
        // Read temperature data
        float temperature = Sensor_ReadTemperature();

        // Control fan
        Control_Update(temperature);

        // Display temperature data
        Display_ShowTemperature(temperature);

        // Send temperature data
        Communication_SendTemperature(temperature);

        // Delay for 1 second
        sleep(1);
    }

    return 0;
}

Code Structure

.
├── main.c
├── sensor.c
├── sensor.h
├── control.c
├── control.h
├── display.c
├── display.h
├── communication.c
└── communication.h

Run Results

After running the program, the output is as follows:

Fan: OFF
LCD: Temperature = 25.00 C
UART: Sending temperature = 25.00 C
Fan: ON
LCD: Temperature = 31.00 C
UART: Sending temperature = 31.00 C

Advantages of Modular Design

1. Maintainability: Each module is independent, modifying one module does not affect others.
2. Scalability: New features can be easily added, such as adding a humidity sensor module.
3. Reusability: Modules can be reused in other projects.
4. Clarity: The code structure is clear and easy to understand and debug.

Conclusion

Through modular design, the development of embedded systems becomes more efficient and flexible. By reasonably partitioning modules, designing interfaces, and establishing module communication mechanisms, efficient and reliable embedded systems can be constructed. Each module focuses on specific functions, and modules communicate through well-defined interfaces. This design approach not only improves code readability and maintainability but also facilitates system expansion and optimization.

END

Lastly, the 21ic Forum (bbs.21ic.com) is recruiting original authors, with a maximum reward of 500 yuan per article. We welcome all netizens to submit! Click to learn more about the event details.Friendly Reminder:

Due to recent changes in WeChat public platform push rules, many readers have reported not seeing updated articles in time. According to the latest rules, it is recommended to frequently click on “Recommended Reading, Share, Favorite”, etc., to become a regular user.

Recommended Reading:

• Forcing employees to buy cars and maliciously terminating contracts leads to rights protection, LeDao responds.

• Completely ceasing production, a ten-year electrical appliance factory declares bankruptcy!

• ByteDance loses the lawsuit, heavily fined 82.66 million, Douyin’s vice president responds helplessly!

Please click 【♡】 to give the editor a thumbs up.