Modular Programming Concepts in Embedded C

Modular Programming Concepts

Modular programming is a programming method that breaks down a program into independent, reusable modules. Each module implements a specific function, and modules interact through clearly defined interfaces. This concept helps improve the maintainability, readability, and scalability of the code.

Preprocessing, Compilation, Assembly, Linking

Preprocessing: Processes preprocessor directives in the source code, such as #include, #define, etc. For example, #include <stdio.h> will insert the contents of the stdio.h header file into the current file.
Compilation: Compiles the preprocessed source code into assembly code or object code. The compiler checks for syntax and semantic errors.
Assembly: Converts assembly code into machine code, generating an object file (e.g., .o file).
Linking: Links multiple object files into a single executable file. The linker resolves symbol references between different modules.

Makefile Compilation

A Makefile is a tool used to automate the compilation process. It defines source files, object files, compilation rules, etc. For example:

CC = gcc
CFLAGS = -Wall -g
all: hello
hello: main.o hello.o	$(CC) $(CFLAGS) -o hello main.o hello.o
main.o: main.c hello.h	$(CC) $(CFLAGS) -c main.c
hello.o: hello.c hello.h	$(CC) $(CFLAGS) -c hello.c
clean:	rm -f *.o hello

This Makefile defines how to compile main.c and hello.c files and link them into an executable named hello.

Linking

Strong Symbols and Weak Symbols: In a multi-file project, multiple strong symbols are not allowed. If there is one strong symbol and multiple weak symbols, the strong symbol is chosen. If there are multiple weak symbols, the one that occupies the most space is selected.
System First, Modules Later: Module division is based on system goals and function definitions, and the implementation process can use inheritance for reuse.

Modular Design and Implementation

Different Modules Implemented with Different Source Files: Each module corresponds to one or more source files, facilitating management and maintenance.
Declaration and Definition: Declaration associates identifiers with C language objects, focusing only on types; definition allocates storage space for objects.
Single Functionality per Module: A function is implemented by a single module, enhancing the independence of the module, reducing dependency on external functions, and increasing the cohesion of the module.

Coupling

Data Coupling: Data is exchanged through parameters. This is the weakest form of coupling, with minimal dependencies between modules.
Label Coupling: Information is passed through parameters. Modules interact through data structures.
Control Coupling: One module controls another through flags or switches. There is a control relationship between modules.
External Coupling: Information is exchanged through global variables. This is the strongest form of coupling, where modules share global variables, making the code difficult to maintain.

Usage of Goto

Restrictions: Can only jump downwards, cannot jump upwards, and can only jump within the same function. Labels divide the function into two different logics. For example:

void example() {
    int x = 0;
    if (x < 0) {
        goto error;
    }
    // Normal logic
    return;
error:
    // Error handling logic
}

Callbacks

Definition: Lower-level modules call upper-level module behaviors through function pointers. For example:

void callback_example(int (*func)(int)) {
    int result = func(5);
    printf("Result: %d\n", result);
}
int add(int x) {
    return x + 10;
}
int main() {
    callback_example(add);
    return 0;
}

Portability

System Call Encapsulation: Encapsulates system calls related to the operating system into a unified interface, hiding the differences between interfaces of different operating systems.
Header File Path Separator: Use the universal / instead of the \ used in Windows.
Standard Syntax: Avoid using compiler-specific extended syntax or features, and write programs using standard C syntax.
Avoid Inline Assembly: Try not to use inline assembly to improve code portability.
Warning Options: Enable all warning options and pay close attention to every warning that appears.
Conditional Compilation: Use conditional compilation to make the code compatible with various platforms. For example:

#ifdef _WINDOWS
    // Windows-specific code
#else
    // Unix-specific code
#endif

Frameworks

Definition: A framework is an extensible application skeleton that allows for rapid development of various applications.
Advantages: Provides common functionalities and structures, reduces redundant development, and improves development efficiency.

The concept of modular programming helps improve the maintainability, readability, and scalability of the code by breaking down the program into independent modules, each implementing a specific function, and allowing interaction through clearly defined interfaces.