1. 定时器与中断：单片机的时间管理大师

记得我刚开始学51单片机那会儿，最让我头疼的就是定时器和中断这两个概念了。每次看到代码里那些TMOD、TCON寄存器配置，脑袋就嗡嗡响。直到有一次做LED闪烁项目，用普通的延时函数实现不了精确控制，才硬着头皮研究定时器，结果发现这东西真的太实用了！

定时器其实就是单片机内部的一个秒表，只不过这个秒表特别精准，它可以独立于主程序运行，到点了就提醒CPU该干活了。而中断系统就像是这个秒表的闹铃功能，时间一到就响铃，CPU不管在做什么都要先来处理定时器的事情。

我建议初学者先把定时器想象成一个厨房用的定时器：你设定好时间（配置寄存器），启动它（TR0=1），然后就可以去忙别的事情了（执行主程序）。等时间到了它会发出"嘀嘀"声（触发中断），你就要放下手中的活来处理（执行中断服务程序）。

2. 定时器工作原理与模式选择

2.1 定时器的核心机制

51单片机通常有两个16位定时器：T0和T1。每个定时器由两个8位寄存器组成（THx和TLx），这样就能组成16位的计数器。上电后这些寄存器初始值都是0，启动后每个机器周期自动加1。

这里有个很重要的概念：机器周期。51单片机中，1个机器周期=12个时钟周期。如果你的晶振是12MHz，那么时钟周期就是1/12微秒，机器周期就是1微秒。这个关系一定要搞清楚，因为所有定时计算都基于这个。

我刚开始总是算错时间，后来发现了个小技巧：用12MHz晶振时，机器周期正好是1微秒，计算起来特别方便。比如要定时50ms，就是50000个机器周期，那么初始值就是65536-50000=15536。

2.2 四种工作模式详解

51单片机的定时器有4种工作模式，通过TMOD寄存器的M1和M0位来设置：

模式0（13位模式）：把TLx的低5位和THx的8位组合成13位计数器。最大计数值8192，现在很少用了，主要是为了兼容老型号。

模式1（16位模式）：这是最常用的模式！THx和TLx组成完整的16位计数器，最大计数值65536。我做项目90%的情况都用这个模式。

模式2（8位自动重装）：TLx作为8位计数器，THx存放重装值。当TLx溢出时，不仅会触发中断，还会自动把THx的值重新装入TLx。特别适合做精确的波特率发生器。

模式3：这个模式比较特殊，只适用于T0。把T0拆成两个独立的8位定时器，TL0用T0的控制位，TH0用T1的控制位。实际项目中用的不多。

我一般这样选择模式：需要长时间定时用模式1，需要精确的串口通信用模式2，其他两种模式基本不用。

3. 定时器实战配置：从LED闪烁到精准定时

3.1 完整的配置步骤

配置定时器其实就6个步骤，我总结了个顺口溜："模式先设定，初值要算清，中断允许开，启动不能忘，中断函数写，重装要记得"。

具体来说：

1. 设置TMOD寄存器选择工作模式
2. 计算并装入定时初值（THx和TLx）
3. 开启中断允许（ETx=1和EA=1）
4. 启动定时器（TRx=1）
5. 编写中断服务函数
6. 在中断中重装初值

让我举个实际例子。假设要用定时器0实现50ms定时，晶振12MHz：

// 步骤1：设置TMOD，选择定时器0模式1
TMOD = 0x01;

// 步骤2：计算并装入初值
TH0 = (65536 - 50000) / 256;  // 高8位
TL0 = (65536 - 50000) % 256;  // 低8位

// 步骤3：开启中断
ET0 = 1;  // 允许定时器0中断
EA = 1;   // 总中断允许

// 步骤4：启动定时器
TR0 = 1;

// 步骤5：中断服务函数
void timer0() interrupt 1
{
    // 步骤6：重装初值
    TH0 = (65536 - 50000) / 256;
    TL0 = (65536 - 50000) % 256;
    
    // 这里写你的处理代码
}

3.2 精准定时1秒的实战技巧

单个定时器最多定时几十毫秒，如果要定时1秒怎么办？我用的是"软件计数器"方法：在中断中设置一个变量，每中断一次加1，加到20次就是1秒（因为50ms×20=1000ms）。

unsigned int count = 0;

void timer0() interrupt 1
{
    TH0 = (65536 - 50000) / 256;
    TL0 = (65536 - 50000) % 256;
    
    count++;
    if(count >= 20)  // 1秒到了
    {
        count = 0;
        // 执行1秒定时任务
        P1_0 = ~P1_0;  // LED状态取反
    }
}

这种方法既简单又实用，我在很多项目中都这样用。记得count变量要定义为全局变量，否则中断函数访问不到。

4. 中断系统深度解析

4.1 中断处理全过程

中断的处理过程就像是你正在看书时电话响了：①标记当前看到哪一页（保护断点）②放下书去接电话（响应中断）③接完电话回来继续看（中断返回）。

51单片机有5个中断源：

• 外部中断0（INT0）
• 定时器0中断（TF0）
• 外部中断1（INT1）
• 定时器1中断（TF1）
• 串口中断（RI/TI）

每个中断源都有固定的中断号，写中断函数时要指定正确的中断号：

void int0_isr() interrupt 0  // 外部中断0
void timer0_isr() interrupt 1 // 定时器0
void int1_isr() interrupt 2   // 外部中断1
void timer1_isr() interrupt 3 // 定时器1
void uart_isr() interrupt 4   // 串口中断

4.2 中断优先级与嵌套

51单片机有两级优先级：高优先级和低优先级。通过IP寄存器设置优先级，某位置1表示高优先级，置0表示低优先级。

如果多个中断同时发生，高优先级的中断先被处理。如果正在处理低优先级中断时来了高优先级中断，就会发生中断嵌套：暂停当前的中断处理，先去处理更高优先级的中断。

我在实际项目中总结了个经验：时间要求严格的中断设为高优先级（比如实时数据采集），其他中断设为低优先级（比如按键检测）。但中断嵌套要谨慎使用，嵌套层次太多容易导致堆栈溢出。

5. 定时器与中断协同工作

5.1 按键消抖的经典应用

机械按键在按下和松开时会产生抖动，通常持续10-20ms。用定时器中断实现消抖既准确又不占用CPU时间。

我的做法是：当检测到按键变化时，启动一个10ms的定时器，定时器溢出后再检测按键状态，如果仍然处于变化后的状态，就认为有效按键。

sbit key = P3^2;  // 按键引脚
bit key_flag = 0;  // 按键有效标志

void timer0() interrupt 1
{
    static unsigned char count = 0;
    
    TH0 = (65536 - 10000) / 256;  // 10ms定时
    TL0 = (65536 - 10000) % 256;
    
    if(!key)  // 按键仍然按下
    {
        count++;
        if(count >= 2)  // 20ms后确认按键
        {
            key_flag = 1;  // 设置按键有效标志
            count = 0;
            TR0 = 0;      // 关闭定时器
        }
    }
    else
    {
        count = 0;
        TR0 = 0;
    }
}

5.2 多任务时间片轮询

在复杂的项目中，我经常用定时器中断实现简单的时间片轮询调度。比如每10ms中断一次，在中断中设置不同的任务标志，主循环中根据标志执行相应任务。

struct {
    bit task1_flag : 1;
    bit task2_flag : 1; 
    bit task3_flag : 1;
} flags;

void timer0() interrupt 1
{
    static unsigned char count = 0;
    
    TH0 = (65536 - 10000) / 256;  // 10ms定时
    TL0 = (65536 - 10000) % 256;
    
    count++;
    if(count % 1 == 0) flags.task1_flag = 1;  // 每10ms
    if(count % 2 == 0) flags.task2_flag = 1;  // 每20ms  
    if(count % 5 == 0) flags.task3_flag = 1;  // 每50ms
    
    if(count >= 10) count = 0;
}

void main()
{
    // 初始化代码...
    
    while(1)
    {
        if(flags.task1_flag) { /* 任务1 */ flags.task1_flag = 0; }
        if(flags.task2_flag) { /* 任务2 */ flags.task2_flag = 0; }
        if(flags.task3_flag) { /* 任务3 */ flags.task3_flag = 0; }
    }
}

这种方法虽然简单，但在很多实际项目中足够用了，能让CPU时间得到合理分配。

6. 常见问题与调试技巧

6.1 定时不准的排查方法

我刚开始用定时器时，经常遇到定时不准的问题。后来总结了一套排查方法：

首先检查晶振频率：代码中定义的FOSC要和实际晶振一致。有人用了11.0592MHz的晶振，代码里却写成12MHz，结果定时当然不准。

其次检查计算过程：定时初值计算是否正确？特别是注意整数除法和取模运算。我建议把计算过程写成宏定义：

#define FOSC 11059200L  // 11.0592MHz
#define TIMER_LOAD_VALUE (65536 - FOSC/12/1000)  // 1ms定时

TH0 = TIMER_LOAD_VALUE / 256;
TL0 = TIMER_LOAD_VALUE % 256;

最后检查中断处理时间：如果中断服务程序执行时间太长，会影响定时精度。尽量让中断函数短小精悍，只做必要的操作，其他处理放到主循环中。

6.2 中断不响应的解决思路

中断不响应是另一个常见问题，我一般从以下几个方面排查：

1. 检查中断允许位：EA（总中断允许）和相应的ETx或EXx位是否设置为1
2. 检查中断标志位：有些中断需要手动清除标志位，比如串口中断的RI和TI
3. 检查中断优先级：高优先级中断长时间执行会阻塞低优先级中断
4. 检查堆栈溢出：中断嵌套太多可能导致堆栈溢出，程序跑飞

我在调试时经常用软件模拟器单步执行，观察中断标志位的变化情况，这样能快速定位问题。

7. 综合实战：智能灯光控制系统

最后分享一个我实际做过的项目：用定时器和中断实现智能灯光控制。功能包括：自动亮度调节、定时开关、按键控制等。

#include <reg52.h>

sbit led = P1^0;     // LED控制引脚
sbit key = P3^2;     // 按键引脚
sbit adc = P1^1;     // 光线传感器

unsigned char brightness = 50;  // 亮度等级
unsigned int timer_count = 0;   // 定时计数器
bit auto_mode = 1;              // 自动模式标志

void timer0_init()
{
    TMOD = 0x01;  // 定时器0模式1
    TH0 = (65536 - 50000) / 256;  // 50ms定时
    TL0 = (65536 - 50000) % 256;
    ET0 = 1;
    EA = 1;
    TR0 = 1;
}

void timer0() interrupt 1
{
    TH0 = (65536 - 50000) / 256;
    TL0 = (65536 - 50000) % 256;
    
    timer_count++;
    
    // 每100ms读取光线传感器
    if(timer_count % 2 == 0)
    {
        if(auto_mode) 
        {
            // 根据光线强度自动调节亮度
            if(adc) brightness++;
            else brightness--;
            
            if(brightness > 100) brightness = 100;
            if(brightness < 10) brightness = 10;
        }
    }
    
    // PWM调光输出
    static unsigned char pwm_count = 0;
    pwm_count++;
    if(pwm_count >= 100) pwm_count = 0;
    
    led = (pwm_count < brightness) ? 1 : 0;
}

void main()
{
    timer0_init();
    
    while(1)
    {
        // 主循环处理其他任务
        // 如按键检测、通信等
    }
}

这个项目综合运用了定时器中断、PWM调光、自动控制等多种技术。关键是合理分配中断和主循环的任务，中断处理时间敏感的操作，主循环处理其他任务。

通过这个实战项目，我深刻体会到定时器和中断的重要性。它们让单片机能够同时处理多个任务，大大提高了系统的效率和实时性。现在做项目，我已经养成了习惯：凡是需要定时或实时处理的功能，首先考虑用定时器中断来实现。