每天一问，关于24位定时器使用T0,T1,T2,T3,T4,T11

独步***

我这儿用 ISP 定时工具生成定时中断1秒   设置主频为40M 代码如下，
但好像中断现象不对，请哪位大神指点一下，这启用24位定时器功能，
还有哪个寄存器需要设置或使能？




//*******************************************************************************
//定时器0初始化        
//*******************************************************************************
void Timer0_Init(void)                //1秒@40.000MHz
{
        TM0PS = 0x32;                        //设置定时器时钟预分频 ( 注意:并非所有系列都有此寄存器,详情请查看数据手册 )
        AUXR &= 0x7F;                        //定时器时钟12T模式
        TMOD &= 0xF0;                        //设置定时器模式
        TL0 = 0xB1;                                //设置定时初始值
        TH0 = 0x00;                                //设置定时初始值
        TF0 = 0;                                  //清除TF0标志
        TR0 = 1;                                  //定时器0开始计时

        ET0 = 1;                                        //使能定时器0中断
       EA = 1;                                                   //总中断允许位打开





}

//*******************************************************************************

//*******************************************************************************
//定时器0中断处理段:
//定时器0中断服务程序，TMR0_VECTOR在AI8051U.H头文件中已宏定义为1
//*******************************************************************************
void Timer0_Isr(void) interrupt TMR0_VECTOR                //定时器0中断服务程序
{
         P27=~P27;                                        //P2.7灯闪烁，中断服务程序中尽量少执行长的任务，防止堵塞其他中断
                            //以上程序代表部分需特急处理的中断事件，可在中断服务程序中直接处理
                            //但时间不要太长，否则会影响其他中断事件的实时响应速度
}

//*******************************************************************************

国芯人***

根据您提供的代码和描述，您在使用24位定时器（T0、T1、T2、T3、T4、T11）时遇到了中断异常的问题。以下是对您问题的详细分析及建议。

一、关于24位定时器的启用与配置

您提到“启用24位定时器功能”，但目前代码中仅对定时器0进行了配置。若您希望使用24位模式（即T0、T1等为24位定时器），需要确保：

1. 设置定时器工作模式为24位模式  
   在标准8051架构中，定时器默认为16位模式。若需使用24位模式（例如T0/T1作为24位定时器），需通过特定寄存器进行配置。具体方式取决于芯片型号，部分型号可能通过AUXR或TMOD寄存器中的特定位来选择模式。
检查您的芯片数据手册，确认是否支持24位定时器模式，并查找对应的寄存器位。
若支持24位模式，通常需要将TMOD的对应位设置为特定值（如0x0C表示T0为24位模式）。

2. 检查主频与定时器时钟源  
   您设定主频为40MHz，但需要注意：
定时器时钟源是否为系统时钟（如12T模式或1T模式）；
如果使用TM0PS寄存器进行预分频，应确认其配置是否正确。

二、代码中存在的潜在问题

1. 定时器初始化不完整
TM0PS = 0x32;：此寄存器可能用于预分频，但并非所有系列都有该寄存器，需参考数据手册确认其作用；
AUXR &= 0x7F;：此操作可能用于设置定时器时钟为12T模式，但具体含义依赖于芯片设计；
TMOD &= 0xF0;：仅保留了低四位，可能未正确设置定时器模式（如24位模式）；
TL0 = 0xB1; TH0 = 0x00;：初始值计算错误，导致定时时间不符合预期。

2. 定时器初值计算错误

在40MHz主频下，若使用12T模式，则定时器时钟频率为 $ \frac{40}{12} \approx 3.333\text{MHz} $。

要实现1秒中断，需计算计数次数：

$$
\text{计数次数} = \frac{3.333 \times 10^6}{1} = 3,333,333
$$

由于16位定时器最大为65536，因此无法直接实现1秒定时，需使用24位模式或外部时钟。

三、建议修改方案

1. 正确配置定时器模式

c
// 设置定时器0为24位模式（假设支持）
TMOD |= 0x0C; // T0为24位模式（示例值，具体请参考数据手册）
复制代码

2. 正确计算并设置初值

假设使用12T模式，主频40MHz，目标为1秒中断：
定时器时钟频率：$ f{CLK} = \frac{40}{12} = 3.333\text{MHz} $
每次计数周期：$ T = \frac{1}{3.333 \times 10^6} \approx 300\text{ns} $
需要计数次数：$ N = 1 / 300 \times 10^{-9} = 3,333,333 $

由于24位定时器可容纳最大值为16,777,216，因此可使用如下初值：

c
TH0 = 0xFF;
TL0 = 0xFF;
复制代码

注意：实际初值需根据具体时钟和模式重新计算。

3. 确保中断使能和优先级设置

c
ET0 = 1;        // 使能定时器0中断
EA = 1;         // 开启全局中断
复制代码

四、其他注意事项
中断服务程序应尽量简短：避免在中断中执行耗时操作，如延时、复杂运算等；
清除TF0标志：在中断服务程序中应手动清除TF0标志，防止重复触发；
检查中断向量地址：确保interrupt TMR0VECTOR定义正确，与芯片中断向量表一致。

五、总结

您当前的代码存在以下问题：

1. 定时器模式未正确设置（可能未启用24位模式）；
2. 初值计算错误，导致定时时间不符；
3. 可能缺少必要的寄存器配置（如TM0PS、AUXR等）；
4. 中断服务程序未处理TF0标志。

建议根据芯片数据手册，结合上述分析调整代码，并验证定时器配置与中断逻辑是否正确。

如需进一步帮助，请提供芯片型号及数据手册相关寄存器说明，以便更精准定位问题。

[本文内容由国芯人工智能辅助生成，仅供参考]

独步***

国芯人*** 发表于 2025-9-5 22:18
根据您提供的代码和描述，您在使用24位定时器（T0、T1、T2、T3、T4、T11）时遇到了中断异常的问题。以下是 ...

感谢！感谢！
我是看着冲哥视频第七集 定时器中断 用ISP复制粘贴做的，就是实现不了同样的LED灯同样慢闪烁，我想一定还工作在16位模式，但PDF文档里也一直找不到正确答案，！

独步***

EAXFR = 1；最后找到是这句应该写在定时器初始化前面，冲哥视频中没交待清楚~ 我们从传统的STC12过来，对于新的一些特殊寄存器使用比较陌生

//**************************************************************
      EAXFR = 1;                         //允许访问扩展的特殊寄存器，XFR   
     Timer0_Init();                     //定时器0初始化,启动

jw***

注意你使用的芯片是否支持42M的主频

神***

从下面这个程序出发：




#include <AI8051U.H>                        //包含AI8051U的头文件

#include "intrins.h"                        //使用_nop_()函数所必须要包含的头文件,
                                                                //否则延时函数中调用的_nop_()函数没有被头文件引用过来，
                                                                //会导致编译器找不到这个而函数而报错。


unsigned char int0_flag = 0;        //定义1个位变量，INT0事件位变量标志，记录INT0已产生中断
// 供主循环查询INT0是否已产生中断，在主循环中处理INT0的中断事件任务，不堵塞其他中断
unsigned char int1_flag = 0;        //定义1个位变量，INT1事件位变量标志，记录INT1已产生中断
// 供主循环查询INT1是否已产生中断，在主循环中处理INT1的中断事件任务，不堵塞其他中断
unsigned char int2_flag = 0;        //定义1个位变量，INT2事件位变量标志，记录INT2已产生中断
// 供主循环查询INT2是否已产生中断，在主循环中处理INT2的中断事件任务，不堵塞其他中断
unsigned char int3_flag = 0;        //定义1个位变量，INT3事件位变量标志，记录INT3已产生中断
// 供主循环查询INT3是否已产生中断，在主循环中处理INT3的中断事件任务，不堵塞其他中断

unsigned char t0_flag = 0;                //定义1个位变量，T0事件位变量标志，记录定时器0已产生中断
// 供主循环查询定时器0是否已产生中断，在主循环中处理定时器0的中断事件任务，不堵塞其他中断
unsigned char t1_flag = 0;                //定义1个位变量，T1事件位变量标志，记录定时器1已产生中断
// 供主循环查询定时器1是否已产生中断，在主循环中处理定时器1的中断事件任务，不堵塞其他中断
unsigned char t3_flag = 0;                //定义1个位变量，T3事件位变量标志，记录定时器3已产生中断
// 供主循环查询定时器3是否已产生中断，在主循环中处理定时器3的中断事件任务，不堵塞其他中断
unsigned char t4_flag = 0;                //定义1个位变量，T4事件位变量标志，记录定时器4已产生中断
// 供主循环查询定时器4是否已产生中断，在主循环中处理定时器4的中断事件任务，不堵塞其他中断

unsigned char uart1_txflag = 0;        //定义1个位变量，UART1事件位变量标志，记录UART1已产生发送中断
// 供主循环查询UART1是否已产生发送中断，在主循环中处理UART1的中断事件任务，不堵塞其他中断
unsigned char uart1_rxflag = 0;        //定义1个位变量，UART1事件位变量标志，记录UART1已产生接收中断
// 供主循环查询UART1是否已产生接收中断，在主循环中处理UART1的中断事件任务，不堵塞其他中断
unsigned char uart2_txflag = 0;        //定义1个位变量，UART2事件位变量标志，记录UART2已产生发送中断
// 供主循环查询UART2是否已产生发送中断，在主循环中处理UART2的中断事件任务，不堵塞其他中断
unsigned char uart2_rxflag = 0;        //定义1个位变量，UART2事件位变量标志，记录UART2已产生接收中断
// 供主循环查询UART2是否已产生接收中断，在主循环中处理UART2的中断事件任务，不堵塞其他中断
unsigned char uart3_txflag = 0;        //定义1个位变量，UART3事件位变量标志，记录UART3已产生发送中断
// 供主循环查询UART3是否已产生发送中断，在主循环中处理UART3的中断事件任务，不堵塞其他中断
unsigned char uart3_rxflag = 0;        //定义1个位变量，UART3事件位变量标志，记录UART3已产生接收中断
// 供主循环查询UART3是否已产生接收中断，在主循环中处理UART3的中断事件任务，不堵塞其他中断
unsigned char uart4_txflag = 0;        //定义1个位变量，UART4事件位变量标志，记录UART4已产生发送中断
// 供主循环查询UART4是否已产生发送中断，在主循环中处理UART1的中断事件任务，不堵塞其他中断
unsigned char uart4_rxflag = 0;        //定义1个位变量，UART4事件位变量标志，记录UART4已产生接收中断
// 供主循环查询UART4是否已产生接收中断，在主循环中处理UART4的中断事件任务，不堵塞其他中断

void Timer0_Init(void)                        //定时器0初始化，2秒@40.000MHz
{
        TM0PS = 0x65;                                //设置定时器时钟预分频 ( 注意:并非所有系列都有此寄存器,详情请查看数据手册 )
        AUXR &= 0x7F;                                //定时器时钟12T模式
        TMOD &= 0xF0;                                //设置定时器模式
        TL0 = 0xB1;                                        //设置定时初始值
        TH0 = 0x00;                                        //设置定时初始值
        TF0 = 0;                                        //清除TF0标志
        TR0 = 1;                                        //定时器0开始计时
        ET0 = 1;                                        //使能定时器0中断
}

void Timer1_Init(void)                        //定时器1初始化，500毫秒@40.000MHz
{
        TM1PS = 0x19;                                //设置定时器时钟预分频 ( 注意:并非所有系列都有此寄存器,详情请查看数据手册 )
        AUXR &= 0xBF;                                //定时器时钟12T模式
        TMOD &= 0x0F;                                //设置定时器模式
        TL1 = 0x99;                                        //设置定时初始值
        TH1 = 0x05;                                        //设置定时初始值
        TF1 = 0;                                        //清除TF1标志
        TR1 = 1;                                        //定时器1开始计时
        ET1 = 1;                                        //使能定时器1中断
}

void Timer3_Init(void)                    //100毫秒@40.000MHz
{
        TM3PS = 0x3D;                            //设置定时器时钟预分频 ( 注意:并非所有系列都有此寄存器,详情请查看数据手册 )
        T4T3M |= 0x02;                            //定时器时钟1T模式
        T3L = 0xFC;                                    //设置定时初始值
        T3H = 0x03;                                    //设置定时初始值
        T4T3M |= 0x08;                            //定时器3开始计时
        IE2 |= 0x20;                            //使能定时器3中断
}

void Timer4_Init(void)                    //200毫秒@40.000MHz
{
        TM4PS = 0x7A;                            //设置定时器时钟预分频 ( 注意:并非所有系列都有此寄存器,详情请查看数据手册 )
        T4T3M |= 0x20;                            //定时器时钟1T模式
        T4L = 0xEF;                                    //设置定时初始值
        T4H = 0x01;                                    //设置定时初始值
        T4T3M |= 0x80;                            //定时器4开始计时
        IE2 |= 0x40;                            //使能定时器4中断
}

void Uart1_Init(void)                        //115200bps@40.000MHz
{
        SCON = 0x50;                                //8位数据,可变波特率
        AUXR |= 0x01;                                //串口1选择定时器2为波特率发生器
        AUXR |= 0x04;                                //定时器时钟1T模式
        T2L = 0xA9;                                        //设置定时初始值
        T2H = 0xFF;                                        //设置定时初始值
        AUXR |= 0x10;                                //定时器2开始计时
        ES = 1;                                                //使能串口1中断
}

void Uart2_Init(void)                        //115200bps@40.000MHz
{
        S2CON = 0x50;                                //8位数据,可变波特率
        AUXR |= 0x04;                                //定时器时钟1T模式
        T2L = 0xA9;                                        //设置定时初始值
        T2H = 0xFF;                                        //设置定时初始值
        AUXR |= 0x10;                                //定时器2开始计时
        IE2 |= 0x01;                                //使能串口2中断
}

void Uart3_Init(void)                        //115200bps@40.000MHz
{
        S3CON = 0x10;                                //8位数据,可变波特率
        S3CON &= 0xBF;                                //串口3选择定时器2为波特率发生器
        AUXR |= 0x04;                                //定时器时钟1T模式
        T2L = 0xA9;                                        //设置定时初始值
        T2H = 0xFF;                                        //设置定时初始值
        AUXR |= 0x10;                                //定时器2开始计时
        IE2 |= 0x08;                                //使能串口3中断
}

void Uart4_Init(void)                        //115200bps@40.000MHz
{
        S4CON = 0x10;                                //8位数据,可变波特率
        S4CON &= 0xBF;                                //串口4选择定时器2为波特率发生器
        AUXR |= 0x04;                                //定时器时钟1T模式
        T2L = 0xA9;                                        //设置定时初始值
        T2H = 0xFF;                                        //设置定时初始值
        AUXR |= 0x10;                                //定时器2开始计时
        IE2 |= 0x10;                                //使能串口4中断
}

void main (void)
{
        EAXFR = 1;                                        //允许访问扩展的特殊寄存器，XFR
        WTST = 0;                                        //设置取程序代码等待时间，赋值为0表示不等待，程序以最快速度运行
        CKCON = 0;                                        //设置访问片内的xdata速度，赋值为0表示用最快速度访问，不增加额外的等待时间

        P0M0 = 0x00; P0M1 = 0x00;         //设置 P0 口为准双向口模式
        P1M0 = 0x00; P1M1 = 0x00;         //设置 P1 口为准双向口模式
        P2M0 = 0x00; P2M1 = 0x00;         //设置 P2 口为准双向口模式
        P3M0 = 0x00; P3M1 = 0x00;        //设置 P3 口为准双向口模式
        P3M0 = 0x00; P3M1 = 0x0c;         //P32、P33设置为高阻输入(需要同步开启上拉电阻)
        P4M0 = 0x00; P4M1 = 0x00;         //设置 P4 口为准双向口模式
        P5M0 = 0x00; P5M1 = 0x00;         //设置 P5 口为准双向口模式
        P6M0 = 0x00; P6M1 = 0x00;         //设置 P6 口为准双向口模式
        P7M0 = 0x00; P7M1 = 0x00;         //设置 P7 口为准双向口模式
       
        P3PU = 0x0c;                                 //P32、P33打开上拉电阻

        int0_flag = 0;                            //初始化用户标志位
        int1_flag = 0;                            //初始化用户标志位
        int2_flag = 0;                            //初始化用户标志位
        int3_flag = 0;                            //初始化用户标志位
   
        t0_flag = 0;                            //初始化用户标志位
        t1_flag = 0;                            //初始化用户标志位
        t3_flag = 0;                            //初始化用户标志位
        t4_flag = 0;                            //初始化用户标志位
   
        uart1_txflag = 0;                        //初始化用户标志位
        uart1_rxflag = 0;                        //初始化用户标志位
        uart2_txflag = 0;                        //初始化用户标志位
        uart2_rxflag = 0;                        //初始化用户标志位
        uart3_txflag = 0;                        //初始化用户标志位
        uart3_rxflag = 0;                        //初始化用户标志位
        uart4_txflag = 0;                        //初始化用户标志位
        uart4_rxflag = 0;                        //初始化用户标志位

        IT0 = 0;                                         //使能 INT0 上升沿和下降沿中断
        //        IT0 = 1;                                 //使能 INT0 下降沿中断
        EX0 = 1;                                         //使能 INT0 中断
        IE0 = 0;                                        //清INT0中断标志

        //        IT1 = 0;                                 //使能 INT1 上升沿和下降沿中断
        IT1 = 1;                                         //使能 INT1 下降沿中断
        EX1 = 1;                                         //使能 INT1 中断
        IE1 = 0;                                        //清INT1中断标志

        INTCLKO |= 0x10;                        //使能INT2中断

        INTCLKO |= 0x20;                        //使能INT3中断
       
        Timer0_Init();                                //调用定时器0初始化函数
        Timer1_Init();                                //调用定时器1初始化函数
        Timer3_Init();                                //调用定时器0初始化函数
        Timer4_Init();                                //调用定时器1初始化函数

        Uart1_Init();                                //调用UART1初始化函数
        Uart2_Init();                                //调用UART2初始化函数
        Uart3_Init();                                //调用UART3初始化函数
        Uart4_Init();                                //调用UART4初始化函数

        EA = 1;                                                //总中断允许位打开
        P40 = 0;                                         //打开LED灯供电
        while(1)                                         //主循环中查询需要处理的各种事件
        {
                /*  本演示程序中，主循环查询各中断有无需要继续处理的事件的次序，
                依次是 INTx/TIMERx/UARTx, 用户可以自己根据实际情况，
                调整查询各中断有无需要继续处理的事件的优先次序  */

                //查询外部中断0事件
                if(int0_flag)                        //主循环中查询，INT0是否已产生中断，是否有需要处理的INT 0事件
                {
                        int0_flag = 0;                //清0，INT0事件位变量标志
                        _nop_();                        //用户在此添加需要处理的事件
                        _nop_();
                }

                //查询外部中断1事件
                if(int1_flag)                        //主循环中查询，INT1是否已产生中断，是否有需要处理的INT1事件
                {
                        int1_flag = 0;                //清0，INT1事件位变量标志
                        _nop_();                        //用户在此添加需要处理的事件
                        _nop_();
                }

                //查询外部中断2事件
                if(int2_flag)                        //主循环中查询，INT2是否已产生中断，是否有需要处理的INT2事件
                {
                        int2_flag = 0;                //清0，INT2事件位变量标志
                        _nop_();                        //用户在此添加需要处理的事件
                        _nop_();
                }

                //查询外部中断3事件
                if(int3_flag)                        //主循环中查询，INT3是否已产生中断，是否有需要处理的INT3事件
                {
                        int3_flag = 0;                //清0，INT3事件位变量标志
                        _nop_();                        //用户在此添加需要处理的事件
                        _nop_();
                }

                //查询定时器0中断事件
                if(t0_flag)                                //主循环中查询，定时器0是否已产生中断，是否有需要处理的定时器0事件
                {
                        t0_flag = 0;                //清0，T0事件位变量标志
                        _nop_();                        //用户在此添加需要处理的事件
                        _nop_();
                }

                //查询定时器1中断事件
                if(t1_flag)                                //主循环中查询，定时器1是否已产生中断，是否有需要处理的定时器1事件
                {
                        t1_flag = 0;                //清0，T1事件位变量标志
                        _nop_();                        //用户在此添加需要处理的事件
                        _nop_();
                }

                //查询定时器3中断事件
                if(t3_flag)                                //主循环中查询，定时器3是否已产生中断，是否有需要处理的定时器3事件
                {
                        t3_flag = 0;                //清0，T3事件位变量标志
                        _nop_();                        //用户在此添加需要处理的事件
                        _nop_();
                }

                //查询定时器4中断事件
                if(t4_flag)                                //主循环中查询，定时器4是否已产生中断，是否有需要处理的定时器4事件
                {
                        t4_flag = 0;                //清0，T4事件位变量标志
                        _nop_();                        //用户在此添加需要处理的事件
                        _nop_();
                }

                //查询串口1中断事件
                if(uart1_txflag)                //主循环中查询，UART1是否已产生发送中断，是否有需要处理的UART1发送事件
                {
                        uart1_txflag = 0;        //清0，UART1发送事件位变量标志
                        _nop_();                        //用户在此添加需要处理的事件
                        _nop_();
                }

                if(uart1_rxflag)                //主循环中查询，UART1是否已产生接收中断，是否有需要处理的UART1接收事件
                {
                        uart1_rxflag = 0;        //清0，UART1接收事件位变量标志
                        _nop_();                        //用户在此添加需要处理的事件
                        _nop_();
                }

                //查询串口2中断事件
                if(uart2_txflag)                //主循环中查询，UART2是否已产生发送中断，是否有需要处理的UART2发送事件
                {
                        uart2_txflag = 0;        //清0，UART2发送事件位变量标志
                        _nop_();                        //用户在此添加需要处理的事件
                        _nop_();
                }

                if(uart2_rxflag)                //主循环中查询，UART2是否已产生接收中断，是否有需要处理的UART2接收事件
                {
                        uart2_rxflag = 0;        //清0，UART2接收事件位变量标志
                        _nop_();                        //用户在此添加需要处理的事件
                        _nop_();
                }

                //查询串口3中断事件
                if(uart3_txflag)                //主循环中查询，UART3是否已产生发送中断，是否有需要处理的UART3发送事件
                {
                        uart3_txflag = 0;        //清0，UART3发送事件位变量标志
                        _nop_();                        //用户在此添加需要处理的事件
                        _nop_();
                }

                if(uart3_rxflag)                //主循环中查询，UART3是否已产生接收中断，是否有需要处理的UART3接收事件
                {
                        uart3_rxflag = 0;        //清0，UART3接收事件位变量标志
                        _nop_();                        //用户在此添加需要处理的事件
                        _nop_();
                }

                //查询串口4中断事件
                if(uart4_txflag)                //主循环中查询，UART4是否已产生发送中断，是否有需要处理的UART4发送事件
                {
                        uart4_txflag = 0;        //清0，UART4发送事件位变量标志
                        _nop_();                        //用户在此添加需要处理的事件
                        _nop_();
                }

                if(uart4_rxflag)                //主循环中查询，UART4是否已产生接收中断，是否有需要处理的UART4接收事件
                {
                        uart4_rxflag = 0;        //清0，UART4接收事件位变量标志
                        _nop_();                        //用户在此添加需要处理的事件
                        _nop_();
                }
        }
}


void int0_isr(void) interrupt INT0_VECTOR
{
        _nop_();                                        //特急处理，中断服务程序中尽量少执行长的任务，防止堵塞其他中断
        //以上程序代表部分需特急处理的中断事件，可在中断服务程序中直接处理
        //但时间不要太长，否则会影响其他中断事件的实时响应速度
        int0_flag = 1;                                // int0_flag置1是通知主循环处理部分INT0中断事件不需要特急处理的任务
                                                                //置1，记录INT0已产生中断，供主循环查询判断有无需处理的INT0任务

        if(INT0)                                         //边沿中断，进入后再次判断电平从而判断是什么样的电平
        {
                _nop_();                                //判断为高电平，则当前为上升沿
                _nop_();                                //可以在这里插入断点进行观察现象
        }
        else
        {
                _nop_();                                //判断为低电平，则当前为下降沿
                _nop_();                                //可以在这里插入断点进行观察现象
        }
}
//INT0中断服务程序，INT0_VECTOR在AI8051U.H头文件中已宏定义为0

void int1_isr(void) interrupt INT1_VECTOR
{
        _nop_();                                        //特急处理，中断服务程序中尽量少执行长的任务，防止堵塞其他中断
        //以上程序代表部分需特急处理的中断事件，可在中断服务程序中直接处理
        //但时间不要太长，否则会影响其他中断事件的实时响应速度
        int1_flag = 1;                                // int1_flag置1是通知主循环处理部分INT1中断事件不需要特急处理的任务
}
//INT1中断服务程序，INT1_VECTOR在AI8051U.H头文件中已宏定义为2

void int2_isr(void) interrupt INT2_VECTOR
{
        _nop_();                                        //特急处理，中断服务程序中尽量少执行长的任务，防止堵塞其他中断
        //以上程序代表部分需特急处理的中断事件，可在中断服务程序中直接处理
        //但时间不要太长，否则会影响其他中断事件的实时响应速度
        int2_flag = 1;                                // int2_flag置1是通知主循环处理部分INT2中断事件不需要特急处理的任务
}
//INT2中断服务程序，INT2_VECTOR在AI8051U.H头文件中已宏定义为10

void int3_isr(void) interrupt INT3_VECTOR
{
        _nop_();                                        //特急处理，中断服务程序中尽量少执行长的任务，防止堵塞其他中断
        //以上程序代表部分需特急处理的中断事件，可在中断服务程序中直接处理
        //但时间不要太长，否则会影响其他中断事件的实时响应速度
        int3_flag = 1;                                // int3_flag置1是通知主循环处理部分INT3中断事件不需要特急处理的任务
}
//INT3中断服务程序，INT3_VECTOR在AI8051U.H头文件中已宏定义为11

void Timer0_Isr(void) interrupt TMR0_VECTOR                //定时器0中断服务程序
{
        _nop_();                                        //特急处理，中断服务程序中尽量少执行长的任务，防止堵塞其他中断
        //以上程序代表部分需特急处理的中断事件，可在中断服务程序中直接处理
        //但时间不要太长，否则会影响其他中断事件的实时响应速度
        t0_flag = 1;                                // t0_flag置1是通知主循环处理部分T0中断事件不需要特急处理的任务
                                                                //置1，记录定时器0已产生中断，供主循环查询判断有无需处理的定时器0任务
}
//定时器0中断服务程序，TMR0_VECTOR在AI8051U.H头文件中已宏定义为1

void Timer1_Isr(void) interrupt TMR1_VECTOR  
{
        _nop_();                                        //特急处理，中断服务程序中尽量少执行长的任务，防止堵塞其他中断
        //以上程序代表部分需特急处理的中断事件，可在中断服务程序中直接处理
        //但时间不要太长，否则会影响其他中断事件的实时响应速度
        t1_flag = 1;                                // t1_flag置1是通知主循环处理部分T1中断事件不需要特急处理的任务
                                                                //置1，记录定时器1已产生中断，供主循环查询判断有无需处理的定时器1任务
}
//定时器1中断服务程序，TMR1_VECTOR在AI8051U.H头文件中已宏定义为3


void Timer3_Isr(void) interrupt TMR3_VECTOR
{
        _nop_();                                        //特急处理，中断服务程序中尽量少执行长的任务，防止堵塞其他中断
        //以上程序代表部分需特急处理的中断事件，可在中断服务程序中直接处理
        //但时间不要太长，否则会影响其他中断事件的实时响应速度
        t3_flag = 1;                                // t3_flag置1是通知主循环处理部分T3中断事件不需要特急处理的任务
                                                                //置1，记录定时器3已产生中断，供主循环查询判断有无需处理的定时器1任务
}
//定时器3中断服务程序，TMR3_VECTOR在AI8051U.H头文件中已宏定义为19

void Timer4_Isr(void) interrupt TMR4_VECTOR
{
        _nop_();                                        //特急处理，中断服务程序中尽量少执行长的任务，防止堵塞其他中断
        //以上程序代表部分需特急处理的中断事件，可在中断服务程序中直接处理
        //但时间不要太长，否则会影响其他中断事件的实时响应速度
        t4_flag = 1;                                // t1_flag置4是通知主循环处理部分T4中断事件不需要特急处理的任务
                                                                //置1，记录定时器4已产生中断，供主循环查询判断有无需处理的定时器1任务
}
//定时器4中断服务程序，TMR4_VECTOR在AI8051U.H头文件中已宏定义为20

void Uart1_Isr(void) interrupt UART1_VECTOR
{
        if (TI)                                                //检测串口1发送中断
        {
                TI = 0;                                        //清除串口1发送中断请求位
                _nop_();                                //特急处理
                //以上程序代表部分需特急处理的中断事件，可在中断服务程序中直接处理
                //但时间不要太长，否则会影响其他中断事件的实时响应速度
                uart1_txflag = 1;                // uart1_txflag置1是通知主循环处理部分串口1发送中断事件不需要特急处理的任务
                                                                //置1，记录UART1已产生发送中断，供主循环查询判断有无需处理的UART1发送任务
        }
        if (RI)                                                //检测串口1接收中断
        {
                RI = 0;                                        //清除串口1接收中断请求位
                _nop_();                                //特急处理
                //以上程序代表部分需特急处理的中断事件，可在中断服务程序中直接处理
                //但时间不要太长，否则会影响其他中断事件的实时响应速度
                uart1_rxflag = 1;                // uart1_rxflag置1是通知主循环处理部分串口1接收中断事件不需要特急处理的任务
                                                                //置1，记录UART1已产生接收中断，供主循环查询判断有无需处理的UART1接收任务
        }
}
//UART1中断服务程序，UART1_VECTOR在AI8051U.H头文件中已宏定义为4

void Uart2_Isr(void) interrupt UART2_VECTOR
{
        if (S2CON & 0x02)                        //检测串口2发送中断
        {
                S2CON &= ~0x02;                        //清除串口2发送中断请求位
                _nop_();                                //特急处理
                //以上程序代表部分需特急处理的中断事件，可在中断服务程序中直接处理
                //但时间不要太长，否则会影响其他中断事件的实时响应速度
                uart2_txflag = 1;                // uart2_txflag置1是通知主循环处理部分串口2发送中断事件不需要特急处理的任务
                                                                //置1，记录UART2已产生发送中断，供主循环查询判断有无需处理的UART2发送任务
        }
        if (S2CON & 0x01)                        //检测串口2接收中断
        {
                S2CON &= ~0x01;                        //清除串口2接收中断请求位
                _nop_();                                //特急处理
                //以上程序代表部分需特急处理的中断事件，可在中断服务程序中直接处理
                //但时间不要太长，否则会影响其他中断事件的实时响应速度
                uart2_rxflag = 1;                // uart2_rxflag置1是通知主循环处理部分串口2接收中断事件不需要特急处理的任务
                                                                //置1，记录UART2已产生接收中断，供主循环查询判断有无需处理的UART2接收任务
        }
}
//UART2中断服务程序，UART2_VECTOR在AI8051U.H头文件中已宏定义为8

void Uart3_Isr(void) interrupt UART3_VECTOR
{
        if (S3CON & 0x02)                        //检测串口3发送中断
        {
                S3CON &= ~0x02;                        //清除串口3发送中断请求位
                _nop_();                                //特急处理
                //以上程序代表部分需特急处理的中断事件，可在中断服务程序中直接处理
                //但时间不要太长，否则会影响其他中断事件的实时响应速度
                uart3_txflag = 1;                // uart3_txflag置1是通知主循环处理部分串口3发送中断事件不需要特急处理的任务
                                                                //置1，记录UART3已产生发送中断，供主循环查询判断有无需处理的UART3发送任务
        }
        if (S3CON & 0x01)                        //检测串口3接收中断
        {
                S3CON &= ~0x01;                        //清除串口3接收中断请求位
                _nop_();                                //特急处理
                //以上程序代表部分需特急处理的中断事件，可在中断服务程序中直接处理
                //但时间不要太长，否则会影响其他中断事件的实时响应速度
                uart3_rxflag = 1;                // uart3_rxflag置1是通知主循环处理部分串口3接收中断事件不需要特急处理的任务
                                                                //置1，记录UART3已产生接收中断，供主循环查询判断有无需处理的UART3接收任务
        }
}
//UART3中断服务程序，UART3_VECTOR在AI8051U.H头文件中已宏定义为17

void Uart4_Isr(void) interrupt UART4_VECTOR
{
        if (S4CON & 0x02)                        //检测串口4发送中断
        {
                S4CON &= ~0x02;                        //清除串口4发送中断请求位
                _nop_();                                //特急处理
                //以上程序代表部分需特急处理的中断事件，可在中断服务程序中直接处理
                //但时间不要太长，否则会影响其他中断事件的实时响应速度
                uart4_txflag = 1;                // uart4_txflag置1是通知主循环处理部分串口4发送中断事件不需要特急处理的任务
                                                                //置1，记录UART4已产生发送中断，供主循环查询判断有无需处理的UART4发送任务
        }
        if (S4CON & 0x01)                        //检测串口4接收中断
        {
                S4CON &= ~0x01;                        //清除串口4接收中断请求位
                _nop_();                                //特急处理
                //以上程序代表部分需特急处理的中断事件，可在中断服务程序中直接处理
                //但时间不要太长，否则会影响其他中断事件的实时响应速度
                uart4_rxflag = 1;                // uart4_rxflag置1是通知主循环处理部分串口4接收中断事件不需要特急处理的任务
                                                                //置1，记录UART4已产生接收中断，供主循环查询判断有无需处理的UART4接收任务
        }
}
//UART4中断服务程序，UART4_VECTOR在AI8051U.H头文件中已宏定义为18

神***

要修改其中的定时器程序可以用下面这个工具：

独步***

[img]感谢各位大神指点!
所谓24位定时器,与我原本的自我理解有误,  是通过TMOPS 8位预分频寄存器,  不断调剂改变定时器的时钟源,  也就是调节定时器时钟源分辨率    去改变中断的频率,   实现上他还是16位定时器,定时值在TH0,TL0里!   为此我还用ISP工具和电子表格验算了一次,  当预分频寄存器TMOPS 的值变大时, 定时器的定时精度分辨率在降低!

这三段是用ISP生成的代码
void Timer0_Init(void)                //500毫秒@40.000MHz
{
        TM0PS = 0x19;                        //设置定时器时钟预分频 ( 注意:并非所有系列都有此寄存器,详情请查看数据手册 )
        AUXR &= 0x7F;                        //定时器时钟12T模式
        TMOD &= 0xF0;                        //设置定时器模式
        TL0 = 0x99;                                //设置定时初始值
        TH0 = 0x05;                                //设置定时初始值
        TF0 = 0;                                //清除TF0标志
        TR0 = 1;                                //定时器0开始计时
}

void Timer0_Init(void)                //1秒@40.000MHz
{
        TM0PS = 0x32;                        //设置定时器时钟预分频 ( 注意:并非所有系列都有此寄存器,详情请查看数据手册 )
        AUXR &= 0x7F;                        //定时器时钟12T模式
        TMOD &= 0xF0;                        //设置定时器模式
        TL0 = 0xB1;                                //设置定时初始值
        TH0 = 0x00;                                //设置定时初始值
        TF0 = 0;                                //清除TF0标志
        TR0 = 1;                                //定时器0开始计时
}


\
void Timer0_Init(void)                //2秒@40.000MHz
{
        TM0PS = 0x65;                        //设置定时器时钟预分频 ( 注意:并非所有系列都有此寄存器,详情请查看数据手册 )
        AUXR &= 0x7F;                        //定时器时钟12T模式
        TMOD &= 0xF0;                        //设置定时器模式
        TL0 = 0xB1;                                //设置定时初始值
        TH0 = 0x00;                                //设置定时初始值
        TF0 = 0;                                //清除TF0标志
        TR0 = 1;                                //定时器0开始计时
}
以下是我的定时精度验算