Click the aboveblue text to follow us
In C language development for microcontrollers, the use of global variables is indeed very common.
This programming style is mainly due to several important reasons:
1
Performance and Resource Constraints
In embedded systems, resources (such as memory and CPU time) are often very limited.
Using global variables can reduce stack space consumption, as global variables are stored in the static memory area, while local variables are stored on the stack.
For some resource-constrained microcontrollers, the stack depth is limited, and global variables can be accessed from anywhere in the code without frequent stack operations, which helps save time and memory.
Especially in embedded environments where real-time requirements are high, reducing the overhead of passing function parameters or assigning return values is a form of optimization.
2
Simplified State Management
Embedded systems often need to manage a large amount of state information, such as sensor data, system status flags, and shared data between tasks.
Global variables can serve as shared memory, making it convenient for different modules or tasks to access and modify.
In a multitasking or interrupt-driven system, using global variables can facilitate data sharing between different contexts without the need for complex function call chains to pass data.
For example, in a flight control system, multiple functional modules need to handle sensor data, attitude calculations, control algorithms, etc.
These modules may execute in different tasks or interrupts, and using global variables allows for easier sharing of state information between modules, thereby reducing the complexity of parameter passing.
3
Reduced Code Complexity
In some cases, the use of function return values may increase code complexity.
Especially in embedded development, if a system involves processing multiple sensor data, control parameters, etc., function return values may require multiple layers of passing and processing.
This not only increases code complexity but also makes it easier to introduce errors. Using global variables can avoid complex parameter passing, making the code simpler.
For example, in a multi-layer processing chain, data needs to be processed and modified by multiple functions.
Using global variables allows data to be directly shared between different functions without repeated passing or multiple copies.
4
Convenience in Interrupt Handling
In embedded systems, interrupts are a very common design pattern.
Interrupt Service Routines (ISRs) typically modify some state or data of the system for use by the main program.
To ensure data consistency between interrupt handling and the main program, global variables are a simpler choice.
Local variables are destroyed after the function exits, while global variables have a lifecycle that spans the entire program runtime, making it a natural way to modify global variables in interrupts.
5
Mapping of Hardware Registers
In microcontroller development, hardware registers are often accessed through global variables or macro definitions.
Although these are not strictly “global variables,” this programming habit leads to a heavy reliance on global variables in the code.
This programming style allows for intuitive hardware manipulation, and for embedded developers, this style has become very common.
6
Disadvantages of Global Variables and Alternatives
While global variables have their advantages, they also bring some issues, such as:
-
Poor maintainability: Global variables can be accessed and modified by any function, making the code difficult to track and debug.
-
Data insecurity: If multiple tasks access global variables simultaneously, it can lead to data race issues, requiring locks or other mechanisms to protect data consistency.
To address these issues, some alternatives can be adopted:
-
Passing local variables and return values: This method aligns better with the modern programming principle of “encapsulation,” reducing dependencies between functions.
-
Struct encapsulation: Encapsulating related variables into a struct and passing them via pointers makes the logical structure of the code clearer.
-
Modular programming: Using the static keyword to limit variable scope to the file, avoiding pollution of the global namespace.
The use of global variables in embedded development is a common practice that balances performance, memory consumption, and code complexity.
However, as system complexity increases, managing global variables properly and avoiding misuse is also something that needs special attention during programming.
Click to read the original text for more exciting content~