全局静态变量为何被重置？测速仪代码故障排查求助

Hey there! Let's break down your problem and fix it step by step. First, let's address your core question: static variables do NOT get automatically reset during program execution—they retain their values for the entire runtime, unless you explicitly assign them a new value or run into memory corruption issues. The "reset" behavior you're seeing is almost certainly due to a bug in how you're declaring/defining your variables, not static itself.

代码里的关键疏漏 #

Let's look at the biggest issues in your code:

1. 重复定义static全局变量（最可能的元凶） #

In your speedometer.h, you've declared variables like:

volatile static uint16_t Speedometer_WheelLength_mm;

Then in speedometer.c, you redefine the same variables with static again:

volatile static uint16_t Speedometer_WheelLength_mm = 2074;

static on global variables limits their scope to the current compilation unit (the .c file they're defined in). When you put static in a header file, every .c file that includes the header will create its own separate copy of that variable.

So when your interrupt modifies Speedometer_Mode or other variables, it's modifying one copy, while your main code (or other parts of the program) are reading a completely different copy. This makes it look like variables are "resetting"—they're not, you're just looking at the wrong version of the variable!

2. 未初始化的变量 #

Some variables are declared in the header but never defined or initialized in the .c file (like Speedometer_RevolutionCounter, Speedometer_TimerCounter, Speedometer_Speed_mmps). While static variables are zero-initialized by default, relying on this can lead to unexpected behavior, especially when dealing with interrupts.

3. 潜在的内存/栈溢出风险 #

If your interrupts are firing too frequently or your stack size is too small, you could run into stack overflow, which can corrupt memory and make variables appear to reset. This is less likely than the duplicate variable issue, but worth checking.

解决方法 #

Let's fix these issues one by one:

1. 修正变量声明/定义模式 #

The correct way to share variables across files is:

• Use extern in the header file to declare variables (tell the compiler "this variable exists somewhere else")
• Define the variables in the .c file (with static if you don't want them accessible outside the .c file, which is good practice for encapsulation)

Updated speedometer.h:

#ifndef SPEEDOMETER_H
#define SPEEDOMETER_H

#include <stdint.h>
#include <stdbool.h>

// Declare variables with extern (no static here!)
extern volatile uint16_t Speedometer_WheelLength_mm;
extern volatile bool Speedometer_IsRunning;
extern volatile uint8_t Speedometer_Mode;
extern volatile uint32_t Speedometer_Speed_mmps;
extern volatile uint8_t Speedometer_RevolutionCounter;
extern volatile uint8_t Speedometer_TimerCounter;
extern volatile uint32_t totalDistance;
extern volatile uint32_t totalTime;
extern volatile uint32_t averageVelocity;
extern volatile uint32_t maxVelocity;
extern volatile uint32_t currentDistance;

// Define your mode constants (adjust values to match your actual code)
#define SPEEDOMETER_SPEED_MEASUREMENT_MODE 0
#define SPEEDOMETER_LAST_MODE 3
#define SPEEDOMETER_GENERAL_SAMPLE_TIME 5

#endif // SPEEDOMETER_H

Updated speedometer.c:

#include "Speedometer.h"

// Define variables here (use static to limit scope to this file)
volatile static uint16_t Speedometer_WheelLength_mm = 2074; // Default value
volatile uint8_t Speedometer_Mode = SPEEDOMETER_SPEED_MEASUREMENT_MODE;
volatile static bool Speedometer_IsRunning = false;
volatile static uint32_t Speedometer_Speed_mmps = 0; // Explicit initialization
volatile static uint8_t Speedometer_RevolutionCounter = 0; // Explicit initialization
volatile static uint8_t Speedometer_TimerCounter = 0; // Explicit initialization
volatile static uint32_t totalDistance = 0;
volatile static uint32_t totalTime = 0;
volatile static uint32_t averageVelocity = 0;
volatile static uint32_t maxVelocity = 0;
volatile static uint32_t currentDistance = 0;

// Rest of your ISR code remains the same
ISR (INT0_vect) {
    // ... your existing code ...
}

ISR (TIMER1_COMPA_vect) {
    // ... your existing code ...
}

ISR (TIMER1_COMPB_vect) {
    // ... your existing code ...
}

ISR (TIMER0_COMPA_vect) {
    // ... your existing button polling code ...
}

2. 显式初始化所有变量 #

Even though static variables are zero-initialized, explicitly setting initial values (like = 0) makes your code clearer and avoids any edge cases with uninitialized memory.

3. 检查中断和栈配置 #

• Ensure you're not defining duplicate ISRs (check all your .c files for conflicting interrupt handlers)
• Verify your AVR's stack size is sufficient (most compilers set this by default, but if you have deep function calls or large local variables in interrupts, you may need to adjust it)

4. 调试验证 #

To confirm the duplicate variable issue is fixed, you can:

• Use a debugger to check the memory address of Speedometer_Mode in both the interrupt and main code—they should be the same now
• Add debug prints (via UART, if your hardware supports it) to track variable values when the mode changes

总结 #

The root cause of your "variable reset" problem is duplicate static variable copies created by declaring static variables in the header file. By switching to extern in the header and defining variables once in the .c file, you'll ensure all parts of your program (including interrupts) are accessing the same variable instances.

内容的提问来源于stack exchange，提问作者Ruslan