Introduction
In embedded development, have you ever encountered a scenario where the value of a global variable suddenly changes? The interrupt service routine has modified it, yet the main program continues to read the old value. Even more frustrating, these issues are often difficult to reproduce, making debugging feel like “catching ghosts.” The root cause of this problem is compiler optimization, which is the main culprit. To improve efficiency, the compiler optimizes variable access by default (such as caching to registers and omitting “redundant” reads), but this can lead to abnormal program behavior in the context of interrupts and hardware register operations. The volatile keyword is the key “solution” to these issues. This article will delve into the principles and applicable scope of volatile, helping you write safer and more reliable code in embedded development.
Principle of the volatile Keyword
The term volatile means “changeable”; it is a type modifier that indicates that this variable may be changed unexpectedly. In other words, volatile tells the compiler that the defined variable may change at any time, so it should not optimize access to this variable. Each time this variable is accessed, it must directly access the variable’s original address rather than through a register. Without the volatile keyword, the compiler may optimize access and temporarily use the value in a register. If this variable is updated by another program, inconsistencies will occur.
Reasons for Variable Changes Due to Interrupts
When a variable is modified in an interrupt service routine and needs to be used elsewhere in the program, the actual parameter’s value is copied and passed to the function’s formal parameter. Modifications to the formal parameter within the function do not affect the actual parameter’s value because the function operates on a copy of the actual parameter, not the actual parameter itself, which is known as pass-by-value. However, when the volatile modifier is added, the address of the actual parameter is passed to the function’s formal parameter. The function can directly access and modify the actual parameter’s value through this address, as the function operates on the actual parameter itself, not its copy, which is known as pass-by-address.
Solutions
By adding the volatile keyword before the defined variable, you can avoid unexpected changes to the variable’s value due to interrupts and other factors.
Applicable Scope of the volatile Keyword
1
Accessing Hardware Registers
1. Accessing hardware registers: In embedded systems, when interacting with hardware device registers, the hardware may modify the register values at any time, such as with timers, serial ports, ADCs, etc. Using volatile ensures that each access retrieves the latest value from the register rather than an outdated value that the compiler may have cached.
2
Multithreaded Programming
2. Multithreaded programming: In a multithreaded environment, when multiple threads share a variable, modifications made by one thread need to be visible to other threads promptly. volatile ensures memory visibility of the variable, allowing each thread to read the latest value and avoiding data inconsistency issues caused by compiler optimization.
3
Interrupt Service Routines
3. Interrupt service routines: Interrupt service routines may modify some global variables, and the main program needs to read these modified variables. volatile ensures that the main program reads the latest values modified by the interrupt service routine, allowing it to respond promptly to changes in variables triggered by interrupts.
Here is the newly opened “Xiao Mei Ge FPGA” service account, which has customer service to provide online Q&A services. Everyone is welcome to ask questions!
Welcome to follow us! We will continue to share problems and solutions encountered in FPGA learning and usage.
END