中断

中断是单片机系统重点中的重点，因为有了中断，单片机就具备了快速协调多模块工作的能力，可以完成复杂的任务。
中断的产生背景

合理巧妙的利用中断，不仅可以使我们获得处理突发状况的能力，而且可以使单片机能够“同时”完成多项任务
定时器中断的应用

定时器一般用法都是采取中断方式来做的。
定时器和中断不是一回事，定时器是单片机模块的一个资源，确确实实存在的一个模块，而中断，是单片机的一种运行机制。
标准 51 单片机中控制中断的寄存器有两个，一个是中断使能寄存器，另一个是中断优先级寄存器。
IE--中断使能寄存器的位分配（地址0xA8、可位寻址）位76543210符号EA--ET2ESET1EX1ET0EX0复位值0--000000IE--中断使能寄存器的位描述位符号描述7EA总中断使能位，相当于总开关6----5ET2定时器2中断使能4ES串口中断使能3ET1定时器1中断使能2EX1外部中断1使能1ET0定时器0中断是使能0EX0外部中断0使能中断使能寄存器IE的位0~5控制了6个中断使能，而第6位没有用到，第7位是宗门光开关。总开关就相当于我们家里或者学生宿舍的那个电源总闸门，而0~5位这6个位相当于每个分开关。那么也就是说，我们只要用到中断，就要写EA=1这一句，打开中断总开关，然后用到哪个分中断，再打开相对应的控制位就可以了。
数码管动态显示，带鬼影

1. #include <reg52.h>
3. sbit ADDR0 = P1 ^ 0;
4. sbit ADDR1 = P1 ^ 1;
5. sbit ADDR2 = P1 ^ 2;
6. sbit ADDR3 = P1 ^ 3;
7. sbit ENLED = P1 ^ 4;
9. unsigned char code LedChar[] = //数码管显示字符转换表
10. {
11.         0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
12.         0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
13. };
15. unsigned char LedBuff[] = //数码管显示缓冲区，初值为0xFF确保启动时都不亮
16. {
17.         0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
18. };
20. void main(void)
21. {
22.         unsigned char i = 0;//动态扫描的索引
23.         unsigned int cnt = 0;//记录T0中断次数
24.         unsigned long sec = 0;//记录经过的秒数
26.         ENLED = 0;//使能U3,选择控制数码管
27.         ADDR3 = 1;//因为需要动态改变ADDR0-2的值，所以不需要再初始化了
28.         TMOD = 0x01;//设置T0为模式1
29.         TH0 = 0xFC;//设置T0赋初值为0xFC67,定时1ms
30.         TL0 = 0x67;
31.         TR0 = 1;//启动T0
33.         while (1)
34.         {
35.                 if (1 == TF0)//判断T0是否溢出
36.                 {
37.                         TF0 = 0;//T0溢出后，清零中断标志
38.                         TH0 = 0xFC;//重新赋初值
39.                         TL0 = 0x67;
40.                         cnt++;//计数值加1
41.                         if (cnt >= 1000)//判读T0溢出是否达到1000次
42.                         {
43.                                 cnt = 0;//达到1000次后计数值清零
44.                                 sec++;//秒计数加1
45.                                 //以下代码将sec按十进制位从低到高依次提取并转为数码管显示字符
46.                                 LedBuff[0] = LedChar[sec % 10];
47.                                 LedBuff[1] = LedChar[sec / 10 % 10];
48.                                 LedBuff[2] = LedChar[sec / 100 % 10];
49.                                 LedBuff[3] = LedChar[sec / 1000 % 10];
50.                                 LedBuff[4] = LedChar[sec / 10000 % 10];
51.                                 LedBuff[5] = LedChar[sec / 100000 % 10];
52.                         }
54.                         //以下代码完成数码管动态扫描刷新
55.                         switch (i)
56.                         {
57.                         case 0:
58.                                 ADDR2 = 0;
59.                                 ADDR1 = 0;
60.                                 ADDR0 = 0;
61.                                 i++;
62.                                 P0 = LedBuff[0];
63.                                 break;
64.                         case 1:
65.                                 ADDR2 = 0;
66.                                 ADDR1 = 0;
67.                                 ADDR0 = 1;
68.                                 i++;
69.                                 P0 = LedBuff[1];
70.                                 break;
71.                         case 2:
72.                                 ADDR2 = 0;
73.                                 ADDR1 = 1;
74.                                 ADDR0 = 0;
75.                                 i++;
76.                                 P0 = LedBuff[2];
77.                                 break;
78.                         case 3:
79.                                 ADDR2 = 0;
80.                                 ADDR1 = 1;
81.                                 ADDR0 = 1;
82.                                 i++;
83.                                 P0 = LedBuff[3];
84.                                 break;
85.                         case 4:
86.                                 ADDR2 = 1;
87.                                 ADDR1 = 0;
88.                                 ADDR0 = 0;
89.                                 i++;
90.                                 P0 = LedBuff[4];
91.                                 break;
92.                         case 5:
93.                                 ADDR2 = 1;
94.                                 ADDR1 = 0;
95.                                 ADDR0 = 1;
96.                                 i = 0;
97.                                 P0 = LedBuff[5];
98.                                 break;
99.                         default:
100.                                 break;
101.                         }
102.                 }
103.         }
104. }

复制代码

数码管动态显示，不带鬼影

1.  
2. #include <reg52.h>
4. sbit ADDR0 = P1 ^ 0;
5. sbit ADDR1 = P1 ^ 1;
6. sbit ADDR2 = P1 ^ 2;
7. sbit ADDR3 = P1 ^ 3;
8. sbit ENLED = P1 ^ 4;
10. unsigned char code LedChar[] = //数码管显示字符转换表
11. {
12.         0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
13.         0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
14. };
16. unsigned char LedBuff[] = //数码管显示缓冲区，初值为0xFF确保启动时都不亮
17. {
18.         0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
19. };
21. unsigned char i = 0;//动态扫描的索引
22. unsigned int cnt = 0;//记录T0中断次数
23. unsigned char flagls = 0;//1秒定时标志
25. void main(void)
26. {
27.         unsigned long sec = 0;//记录经过的秒数
29.         EA = 1;//使能总中断
31.         ENLED = 0;//使能U3,选择控制数码管
32.         ADDR3 = 1;//因为需要动态改变ADDR0-2的值，所以不需要再初始化了
33.         TMOD = 0x01;//设置T0为模式1
34.         TH0 = 0xFC;//设置T0赋初值为0xFC67,定时1ms
35.         TL0 = 0x67;
36.         ET0 = 1;//使能T0中断
37.         TR0 = 1;//启动T0
39.         while (1)
40.         {
41.                 if(1 == flagls)//判断1秒定时标志
42.                 {
43.                         flagls = 0;//1秒定时标志清零
44.                         sec++;//秒计数加1
46.                         //以下代码将sec按十进制位从低到高依次提取并转为数码管显示字符
47.                         LedBuff[0] = LedChar[sec % 10];
48.                         LedBuff[1] = LedChar[sec / 10 % 10];
49.                         LedBuff[2] = LedChar[sec / 100 % 10];
50.                         LedBuff[3] = LedChar[sec / 1000 % 10];
51.                         LedBuff[4] = LedChar[sec / 10000 % 10];
52.                         LedBuff[5] = LedChar[sec / 100000 % 10];
53.                 }
54.         }
55. }
57. /* 定时器中断服务函数 */
58. void InterruptTimer0() interrupt 1
59. {
60.         TH0 = 0xFC;//重新赋初值
61.         TL0 = 0x67;
62.         cnt++;//中断次数计数值加1
64.         if (cnt >= 1000)//中断1000次即1秒
65.         {
66.                 cnt = 0;//清零计数值以重新开始下一秒计时
67.                 flagls = 1;//设置1秒定时标志位1
68.         }
70.         //以下代码完成数码管动态扫描刷新
71.         P0 = 0xFF;//显示消隐
72.         switch (i)
73.         {
74.         case 0:
75.                 ADDR2 = 0;
76.                 ADDR1 = 0;
77.                 ADDR0 = 0;
78.                 i++;
79.                 P0 = LedBuff[0];
80.                 break;
81.         case 1:
82.                 ADDR2 = 0;
83.                 ADDR1 = 0;
84.                 ADDR0 = 1;
85.                 i++;
86.                 P0 = LedBuff[1];
87.                 break;
88.         case 2:
89.                 ADDR2 = 0;
90.                 ADDR1 = 1;
91.                 ADDR0 = 0;
92.                 i++;
93.                 P0 = LedBuff[2];
94.                 break;
95.         case 3:
96.                 ADDR2 = 0;
97.                 ADDR1 = 1;
98.                 ADDR0 = 1;
99.                 i++;
100.                 P0 = LedBuff[3];
101.                 break;
102.         case 4:
103.                 ADDR2 = 1;
104.                 ADDR1 = 0;
105.                 ADDR0 = 0;
106.                 i++;
107.                 P0 = LedBuff[4];
108.                 break;
109.         case 5:
110.                 ADDR2 = 1;
111.                 ADDR1 = 0;
112.                 ADDR0 = 1;
113.                 i = 0;
114.                 P0 = LedBuff[5];
115.                 break;
116.         default:
117.                 break;
118.         }
119. }

复制代码

在程序中，有两个函数，一个是主函数，一个是中断服务函数。
中断服务函数的书写格式是固定的，首先中断服务函数前边void表示函数返回值为空，即中断服务函数不返回任何值，函数名是可以在满足命名规则的前提下随机取的，而后是 interrupt 这个关键字，一定不能错，这是中断所特有的关键字，另外后边还有个数字1，数字1是中断函数编号
中断查询序列中断函数编号中断名称中断标志位中断使能位中断向量地址默认优先级0外部中断0IE0EX00x00031(最高)1T0中断TF0ET00x000B22外部中断1IE1EX10x001333T1中断TF1ET10x001B44UART中断T1/R1ES0x002355T2中断TF2/EXF2ET20x002B6如上表，如果需要使能T0中断，就要把它的中断使能位ET0置1，当它的中断标志位TF0变为1时，就会触发T0中断了，那么这时就应该执行中断函数了，单片机又是怎样找到这个中断函数呢？靠的就是中断向量地址，所以 interrupt 后面的中断函数编号的数字 x 技术根据中断向量得出的，它的计算方法是 x*8+3=向量地址。最后算出即为表中的值。
中断函数写好后，每当满足中断条件而触发中断后，系统就会自动来调用中断函数。
中断优先级

中断优先级有两种，一种是抢占优先级，一种是固有优先级。

IP这个寄存器的每一位，表示对应中断抢占优先级，每一位的复位值都是0，当我们把某一位设置为1的时候，这一位的优先级就比其他位的优先级高了。
当进入低优先级中断中执行时，如又发生高优先级的中断，则立刻进入高优先级中断执行，处理完高优先级极中断后，再返回处理低优先级中断，这个过程就叫做中断嵌套，也称为抢占。
所以抢占优先级的概念就是，优先级高的中断可以打断优先级低的中断的执行，从而形成嵌套。当然反过来，优先级低的中断是不能打断优先级高的中断的。
那么既然有抢占优先级，自然就有非抢占优先级，也称为固有优先级。在“终端查询序列”表中的最后一列给出的技术固有优先级，请注意，在中断优先级的编号中，一般是数字越小优先级越高。从表中可以看出一共有1~6共6级优先级，这里的优先级与抢占优先级的一个不同点就是，它不具有抢占的特性，也就是说即使在低优先级中断执行过程中又发生了高优先级的中断，那么这个高优先级的中断也只能等到低优先级中断完成后才能得到响应。既然不能抢占，那么这个优先级有什么作用呢？
答案是多个中断同时存在时的仲裁。比如说有多个中断同时发生了，当然实际上发生这种情况的概率很低，但另外一种情况就常见的多了，那就是出于某种原因我们暂时关闭了总中断，即EA=0，执行完一段代码后又重新使能了总中断，即EA=1，那么在这段时间里就很可能有多个中断都同时发生了，但因为总中断是关闭的，所以它们当时都得不到响应，而当总中断再次使能后，它们就会在同时请求响应了，很明显，这时也必须有个先后顺序才行，这就是非抢占优先级的作用。
抢占优先级和非抢占优先级的协同，可以使单片机中断系统有条不紊的工作，既不会无休止的嵌套，又可以保证必要时紧急任务得到优先处理。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！