单片机中，中断算是一个比较重要的部分，在51单片机中有八种中断方式 ，其中常用的的有五种，分别是外部中断0，计时器中断0，外部中断1，计时器中断1，和串口中断。今天主要介绍的是计时器中断。

    51单片机给我们提供了2个计时器中断，分别是计时器0和计时器1，他们对应的优先级分别是1和3，开启计时器并允许其中断后，计时器会从给定的初始值开始，每个指令周期加1，直到加到65535，再加一时计时器溢出，计时器此时会进入中断，并执行中断服务函数。

    在编程过程中发现有许多人搞不清中断服务函数与一般函数的区别，他们总是问出诸如中断服务函数在程序中哪一句之前或哪一句之后执行的问题。其实中断服务函数虽然也是个函数，但是它与一般函数还是有一定的区别的。一般函数想使用时，必须要在主函数或其他函数中调用。而中断服务函数，只要在主函数中初始化计时器后，当计时器进入中断时会中止单片机进行的所有操作，开始执行中断服务函数，在执行完中断服务函数后再回到执行中断服务函数前执行的地方继续执行。其实中断服务函数也是被调用了，但它不是被程序中的某一句话调用了，而是被单片机调用了。

    单片机单片机存储程序并不是从0地址开始保存，而是在中端向量表后保存，中断向量表中保存的是中断的优先级和中断服务函数的地址。程序执行后一旦计时器进入中断状态，单片机会回到中断向量表查询中断的优先级和中断服务函数的地址，然后跳转到中断服务函数所在地址开始执行，执行完成后回到中断向量表，然后回到中断前的地方执行。

    单片机的初始化有5步：

    1.打开总中断。

    2.选择工作方式。

    3.计时器初始化。

    4.打开计时器中断允许。

    5.开始计时。

 

   下面以定时器0为例就按照上面五个步骤写一个1ms执行一次中断函数的初始化函数。

    void tiemr0_init()

   ｛

          EA = 1;        //打开总中断

          TMOD |= 0x01;   //选择工作方式1      *注1

          TH0 = (65536 - 1000) / 256;     //定时器高八位初始化

          TL0 = (65536 - 1000) %256;    // 定时器低八位初始化

          ET0 = 1;  //打开定时器0中断允许

          TR0 = 1; //定时器0开始计时

    ｝

注1：TMOD寄存器有八位，其中高八位用于选择定时器1的工作方式，低八位用于选择定时器0 的工作方式，定时器1有三种工作方式，定时器1有四种工作方式。



一般定时器中断时使用方式一，也就是用定时器0(T0)时 TMOD |= 0x01，用定时器1(T1)时 TMOD |= 0x10，方式2一般用于串口中断，其余两种涉及不多。

中断服务函数只需要在函数名后加interrupt X ，X就是中断对应的优先级，如定时器0中断对应的优先级是1，那他的中断服务函数名后面就加interrupt 1,下面就以定时器0为例编写一个使count一毫秒加一的中断服务函数（晶振为12M）

unsigned char count = 0;

void timer0_isr() interrupt 1

{   

      TH0 = (65536 - 1000) / 256;

      TL0 = (65536 - 1000) % 256;   

      count++;

}

#include <reg51.h>


#include <intrins.h>


unsigned char code LED7Code[] = {0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,//0-9字模


0x88,0x83,0xc6,0xa1,0x86,0x8e};//共阳极7段数码管A-F字模,原来的是错误的.


unsigned char num,temp;
unsigned int a, b,c;


void system_init()


{


  EA=1; //开中断总开关


  ET0=1;//加一行,开定时器T0中断


  TMOD=0x01;	//定时器0方式1


  TH0=(65535-50000)/256;	//定时50ms


  TL0=(65535-50000)%256;


  num=0;


  temp=0;


  TR0=1;	//开定时器0


  P0=LED7Code[num]; //不能是num++


}
void delay(int m){
	while(m--);
}
void main()


{


  system_init();	//参数初始化


  while(1)


  {
   if(temp==20)	//定时1s,刷新数码管数字显示


	{
	
		temp=0;	//标志位置零,计数程序修改后是这样的
		
		num++; //原来的写法有问题
		
			//显示字符,不能是num++
	
	}
	
	    a = num % 10;
	    b = num/10%10;
		c = num/100;
		P2 = 0xdf;
		delay(500);
		P0=LED7Code[a];
		P2 = 0x7f;
		delay(500);
		P0=	LED7Code[b];
		P2=0xbf;
		delay(500);
		P0=	LED7Code[c];


  }


}


void Time() interrupt 1 using 1    	//中断函数


{


    TH0=(65535-50000)/256;	//定时50ms


    TL0=(65535-50000)%256;


	temp++;


}

计时报警器
实现效果：

初始显示器增加

按第一个键使它减

按第二个键使它加

按第三个键使它暂停，再按一次恢复

当显示器显示90并仍在递增时报警，直到100停止

代码：
#include<reg52.h>
#define uint unsigned int
#define uchar unsigned char
unsigned int SystemTime=0;
sbit wela=P2^7;
sbit dula=P2^6;
sbit keyadd=P3^0;
sbit keydec=P3^1;
sbit keystop=P3^2;
sbit beef=P2^3;
void delay(uint a);
void br(uint t);
void display(uint a,uint b);
void dec();
void add();
void stop();
uint k;
uchar code wei[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};
uchar code duan[]={
0x3f,0x06,0x5b,0x4f,
0x66,0x6d,0x7d,0x07,
0x7f,0x6f,0x77,0x7c,
0x39,0x5e,0x79,0x71};//0-F，code：定义在储存区，不能修改
void timer0() interrupt 1
{

    TH0=(65536-1000)/256;
    TL0 = (65536-1000)%256;  //1ms
   SystemTime++;
}
		 	  
void br(uint t)
{
   beef=0;
   delay(t);
   beef=1;
}
void delay(uint a)
{		 
        
		 TH0=(65536-1000)/256;
		 TL0 = (65536-1000)%256; 
		 while(SystemTime!=a)
		 {
		 TR0 = 1;
		 }
		 TR0 = 0;
		 SystemTime=0;		    
}
void display(uint a,uint b)
{         
	   P0=wei[0]; 
	   wela=1;
	   wela=0;
       P0=duan[a];
       dula=1;
	   dula=0;
	  	 delay(5);
	   P0=wei[1]; 
	   wela=1;
	   wela=0;
       P0=duan[b];
       dula=1;
	   dula=0;
		  delay(5);
		  
}

void main()
{	 	uint i,ge,shi,num;
        ET0 = 1; 
        EA=1;
	    TMOD=0x01;
		num=50 ;
	
  while(1)
  {	  		
		for(i=0;i<=99;i++)
	  	{	k=i;
		      stop();
		    ge=i%10;
		    shi=i/10;
			if(i>=90&&i<=99)
			{
			br(10);
			}
			 stop();
			 while(num!=0)
			 {
			 display(shi,ge);
			 num--;
			 stop();
			 add();
			 dec();
			 
			 }
			 num=50;
			 if(i==99)
			 {	 
			   i=0;
			 }
			
			 
			 add();
			 dec();
			 stop();
			 
			}
 }
}

void add( )
{	 uint i,ge,shi,num;
    
	   num=50;
		  if(keyadd!=1)
		  {
			 for(i=k;i<=99;i++)
			 {	  k=i;
			 ge=i%10;
		    shi=i/10;
			if(i>=90&&i<=99)
			{
			br(10);
			}
			 while(num!=0)
			 {
			 display(shi,ge);
			 num--;
			 dec();
			 stop();
			 }
			 num=50;
			 if(i==99)
			 {	 
			   i=0;
			 }
			 k=i;
		
			 
		  }
		  }
		
}
void dec( )
{	  uint i,ge,shi,num;
	   num=50;
	
		  if(keydec!=1)
		  {
			 for(i=k;i>=0;i--)
			 {	k=i;
			 ge=i%10;
		    shi=i/10;
			 while(num!=0)
			 {
			 display(shi,ge);
			 num--;
			 add();
			 stop();
			 }
			 num=50;
			 if(i==0)
			 {	 
			   i=99;
			 }
			 k=i;
		
		
		  }
		  }
			

}
 void stop()
{	 uint ge,shi; 

	  if(keystop!=1)	 
	  {	  delay(5);
	     if(keystop!=1)
		 {
	         ge=k%10;
		    shi=k/10;
			 while(!keystop);
			 delay(5);
			 while(!keystop);
			 while(1)
			 {
			 display(shi,ge);
			 add();
			 dec();
			 if(keystop!=1)
		 {	  delay(5);
		 if(keystop!=1)
		 {
		      break;
		 }
			
	}			
			 }
			 while(!keystop);
			 display(shi,ge);
			 delay(5);
			 while(!keystop);
			 }
			} 
			
	}

51单片机-计时器-倒计时闹钟

1. 视频
bilibili视频地址：
https://www.bilibili.com/video/av91943244

                        
                        
51单片机-计时器-倒计时闹钟
                    

2. 文件
文件下载地址：
https://download.csdn.net/download/weixin_43130546/12194355
3. 说明
注意KeyScan()函数if语句！

蜂鸣器频率问题；

想到再补充。
4. 代码

#include <reg52.h>

sbit BUZZER = P2^3;

sbit DULA = P2^6;
sbit WELA = P2^7;

sbit KEYOUT1 = P3^0;
sbit KEYOUT2 = P3^1;
sbit KEYOUT3 = P3^2;
sbit KEYOUT4 = P3^3;
sbit KEYIN1 = P3^4;
sbit KEYIN2 = P3^5;
sbit KEYIN3 = P3^6;
sbit KEYIN4 = P3^7;

unsigned char code DUTable[16] = 
{
	0x3F,0x06,0x5B,0x4F,
	0x66,0x6D,0x7D,0x07,
	0x7F,0x6F,0x77,0x7C,
	0x39,0x5E,0x79,0x71
};

unsigned char code WETable[8] = 
{
	~0x80,~0x40,~0x20,~0x10,
	~0x08,~0x04,~0x02,~0x01
};

unsigned char LedBuff[8] = 
{
	0x3F,0x00,0x00,0X00,
	0X00,0X00,0X00,0X00
};

unsigned char code KeyCode[4][4] = 
{
	{0x31,0x32,0x33,0x26},		   //	1		2		3		up
	{0x34,0x35,0x36,0x25},		   //	4		5		6		left
	{0x37,0x38,0x39,0x28},		   //	7		8		9		down
	{0x30,0x1B,0x0D,0x27}		   //	0		ESC		enter	right
};

unsigned char KeyStay[4][4] = 
{
	{1,1,1,1},{1,1,1,1},{1,1,1,1},{1,1,1,1}
};

unsigned long pdata KeyTime[4][4] = 
{
	{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0}
};

unsigned char T0RH,T0RL;
bit enBuzz = 0;
bit flagCount = 0;
bit flag1s = 0;
unsigned long CountNum = 0;

void ConfigTimer0(unsigned char ms);
void KeyDriver(void);
void ShowNumber(void);

void main(void)
{
	ConfigTimer0(1);
	while(1)
	{
		KeyDriver();
		if(flagCount && flag1s)
		{
			flag1s = 0;
			if(CountNum > 0)
			{
				CountNum--;
				ShowNumber();
				if(0 == CountNum)
				{
					enBuzz = 1;
					P1 = 0x00;
					flagCount = 0;
				}
			}
		}
	}
}

void ConfigTimer0(unsigned char ms)
{
	unsigned long tmp;

	tmp = 11059200 / 12;
	tmp = tmp * ms / 1000;
	tmp = 65536 - tmp;
	tmp += 18;

	T0RH = (unsigned char)(tmp>>8);
	T0RL = (unsigned char)tmp;

	TH0 = T0RH;
	TL0 = T0RL;
	TMOD &= 0xF0;
	TMOD |= 0x01;
	EA = 1;
	ET0 = 1;
	TF0 = 0;
	TR0 = 1;
}

void ShowNumber(void)
{
	char i;
	unsigned long num = CountNum;
	unsigned char buff[8];

	for(i=0; i<8; i++)
	{
		buff[i] = num % 10;
		num /= 10;
	}
	for(i=7; i>=1; i--)
	{
		if(0 == buff[i])
		{
			LedBuff[i] = 0x00;
		}
		else
		{
			break;
		}
	}
	for(; i>=0; i--)
	{
		LedBuff[i] = DUTable[buff[i]];
	}
}

void KeyAction(unsigned char KeyCoder)
{
	if((0x26 == KeyCoder) || (0x25 == KeyCoder))
	{
		if(CountNum < 99999999)
		{
			CountNum++;
			ShowNumber();
		}
	}
	else if((0x28 == KeyCoder) || (0x27 == KeyCoder))
	{
		if(CountNum > 0)
		{
			CountNum--;
			ShowNumber();
		}
	}
	else if(0x0D == KeyCoder)
	{
		flagCount = 1;
	}
	else if(0x1B == KeyCoder)
	{
		enBuzz = 0;
		//P1 = 0xFF;
		flagCount = 0;
		CountNum = 0;
		ShowNumber();
	}
}

void KeyDriver(void)
{
	unsigned char i,j;
	static unsigned char KeyBack[4][4] = 
	{
		{1,1,1,1},{1,1,1,1},{1,1,1,1},{1,1,1,1}
	};
	static unsigned long pdata KeyTimer[4][4] = 
	{
		{1000,1000,1000,1000},{1000,1000,1000,1000},
		{1000,1000,1000,1000},{1000,1000,1000,1000}
	};

	for(i=0; i<4; i++)
	{
		for(j=0; j<4; j++)
		{
			if(KeyStay[i][j] != KeyBack[i][j])
			{
				if(1 == KeyBack[i][j])
				{
					P1 = 0x00;
					KeyAction(KeyCode[i][j]);
				}
				else
				{
					P1 = 0xFF;
				}
				KeyBack[i][j] = KeyStay[i][j];
			}

			if(KeyTime[i][j] > 0)
			{
				if(KeyTime[i][j] >= KeyTimer[i][j])
				{
					KeyTimer[i][j] += 200;
					if((KeyCode[i][j] == 0x26) || (KeyCode[i][j] == 0x28))
					{
						enBuzz = 1;
						KeyAction(KeyCode[i][j]);
						enBuzz = 0;
					}
				}
			}
			else
			{
				KeyTimer[i][j] = 1000;
			}
		}
	}
}

void LedScan(void)
{
	static unsigned char i = 0;

	P0 = 0x00;
	DULA = 1;
	DULA = 0;
	P0 = WETable[i];
	WELA = 1;
	WELA = 0;
	P0 = LedBuff[i];
	DULA = 1;
	DULA = 0;

	i++;
	if(i>=8)
	{
		i = 0;
	}
}

void KeyScan(void)
{
	unsigned char i;
	static unsigned char KeyOut = 0;
	static unsigned char KeyBuff[4][4] = 
	{
		{0xF,0xF,0xF,0xF},{0xF,0xF,0xF,0xF},
		{0xF,0xF,0xF,0xF},{0xF,0xF,0xF,0xF}
	};

	KeyBuff[KeyOut][0] = (KeyBuff[KeyOut][0] << 1) | KEYIN1;
	KeyBuff[KeyOut][1] = (KeyBuff[KeyOut][1] << 1) | KEYIN2;
	KeyBuff[KeyOut][2] = (KeyBuff[KeyOut][2] << 1) | KEYIN3;
	KeyBuff[KeyOut][3] = (KeyBuff[KeyOut][3] << 1) | KEYIN4;

	for(i=0; i<4; i++)
	{
		if(0x00 == (KeyBuff[KeyOut][i] & 0x0F))
		{
			KeyStay[KeyOut][i] = 0;
			KeyTime[KeyOut][i] += 4;
		}
		else if(0x0F == (KeyBuff[KeyOut][i] & 0x0F))
		{
			KeyStay[KeyOut][i] = 1;
			KeyTime[KeyOut][i] = 0;
		}
	}

	KeyOut++;
	KeyOut &= 0x3;

	switch(KeyOut)
	{
		case 0 : KEYOUT4 = 1; KEYOUT1 = 0; break;
		case 1 : KEYOUT1 = 1; KEYOUT2 = 0; break;
		case 2 : KEYOUT2 = 1; KEYOUT3 = 0; break;
		case 3 : KEYOUT3 = 1; KEYOUT4 = 0; break;
		default : break;
	}
}

void BuzzScan(void)
{
	if(enBuzz)
	{
		BUZZER = ~BUZZER;
	}
	else
	{
		BUZZER = 1;
	}
}

void InterruptTimer0(void) interrupt 1
{
	static unsigned int tmr1s = 0;

	TH0 = T0RH;
	TL0 = T0RL;

	LedScan();
	KeyScan();
	BuzzScan();

	if(flagCount)
	{
		tmr1s++;
		if(tmr1s>=1000)
		{
			tmr1s = 0;
			flag1s = 1;
		}
	}
	else
	{
		tmr1s = 0;
	}
}