精华内容
下载资源
问答
  • 51单片机计时器

    2014-05-22 17:56:09
    51单片机制作赛道计时器程序,用红外对管
  • 51单片机 计时器

    2013-01-09 20:02:32
    51单片机上用汇编语言实现的计时器的程序
  • 基于C51单片机计时器

    2019-05-02 17:07:06
    1)上电启动后,时钟计时,显示器显示00:00,并开始计时,每过1秒加1,直至59:59,再加1回到00:00,循环一次是60分钟,计时结束后蜂鸣响一声报警提示。 2)按下K1键后,选择秒表计时,显示器显示00:00,每过1秒加1...
  • 51单片机计时器中断

    千次阅读 2017-10-12 08:40:17
     51单片机给我们提供了2个计时器中断,分别是计时器0和计时器1,他们对应的优先级分别是1和3,开启计时器并允许其中断后,计时器会从给定的初始值开始,每个指令周期加1,直到加到65535,再加一时计

     单片机中,中断算是一个比较重要的部分,在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++;

    }

    展开全文
  • 用来计算51单片机计时器初值。该程序要在命令行模式(CMD)下运行。若程序不能运行,请安装.net3.5。
  • 51单片机上设计一个连续的计时器(对时、分、秒累计,计秒的范围为0~60,计分的范围为1~60,计时的范围为0~9999),并在数码管上采用计时单元和显示缓冲单元分开显示.用C语言编写
  • 本资源仅适用于 51单片机的定时器初值设定
  • 基于89c52的计时器,主要用到计时计数中断,提供详细的编程,仅供学习参考
  • 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字模,...
    #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++;


    }
    展开全文
  • 51单片机计时器程序 编写语言:C 运行情况:完美运行
  • 51单片机-计时器-倒计时闹钟
  • 51单片机计时报警

    2019-11-11 19:52:16
    计时报警 实现效果: 初始显示器增加 按第一个键使它减 按第二个键使它加 按第三个键使它暂停,再按一次恢复 当显示器显示90并仍在递增时报警,直到100停止 代码: #include #define uint unsigned int #define ...

    计时报警器

    实现效果:
    初始显示器增加
    按第一个键使它减
    按第二个键使它加
    按第三个键使它暂停,再按一次恢复
    当显示器显示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单片机上的模块,实现的一个能够到数60秒以内的倒数计时器
  • 51单片机利用计时器在示波器上输出方波
  • 51单片机番茄计时器

    2018-11-07 21:16:44
    番茄工作法是简单易行的时间管理方法,是由弗朗西斯科·西里洛于1992年创立的一种相对于GTD更微观的时间管理方法。
  • 利用51单片机设计并制作一种计时器。主要有计时功能和LED实时显示功能。 功能: (1)设置计时器电路,采用LED实时显示当前计时数值; (2)可由按键结束计时功能,并进行蜂鸣器报警; (3)通过按键把LED示数清零。...
  • 51单片机-计时器-倒计时闹钟

    千次阅读 2020-02-27 12:22:53
    51单片机-计时器-倒计时闹钟 1. 视频 bilibili视频地址: 2. 文件 文件下载地址: 3. 说明 注意KeyScan()函数if语句! 蜂鸣器频率问题; 想到再补充。 4. 代码 #include <reg52.h> sbit BUZZER = P2^3; ...

    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;
    	}
    }
    
    
    展开全文
  • 基于51单片机的篮球计时器(C语言实现)。基于51单片机的篮球计时器(C语言实现)。基于51单片机的篮球计时器(C语言实现)。
  • 单片机计时器

    2020-04-20 22:47:32
    使用的是51单片机, 晶振为11.0592M的, 时间选择5ms。 这篇博客好像是第一篇单片机博客诶~。 算法: 简单的计时器应用, 最开始 根据   2^16 - (t - f)/12  计算得到值, 将其转换为16进制&...
  • 51单片机 —— 计时器

    2018-05-30 10:57:00
    每四位寄存器中,低两位定义定时器的工作方式(方式一与方式二),第三位是功能选择位(定义计时器为定时或计数),第四位为门控位,决定INTx引脚输入电平的影响,也可理解为是否引入外部控制定时器的启停动作。...
  • 基于51单片机的时钟计时器,里面包含C代码以及PCB原理图
  • 51单片机计时器

    2016-10-22 01:26:50
    今天1点25,计时器成功运行,有点爽,但是距离目标还是挺远的,加油,我的时钟。。 求大神收留我啊
  • 51单片机简单计时器

    千次阅读 2018-05-15 17:07:03
    #include &lt;reg52.h&gt;#define uint8 unsigned char#define uint16 unsigned short int//数码管段码显示:0~f,不亮uint8 code LED_Disp[] = {0xC0,0xF9,0xA4,0xB0, //这一组编码当中不包含小数点 0x99,...
  • 设计要求: 1:上电后二位数码管显示882:单击按钮,倒计时开始从20秒开始,到0时喇叭发声。3:双击按钮开关:倒计时从0开始正常记时,到20秒后发声。4:记数结束从开始状态重新开始下一轮.
  • 精确到0.01S的C51单片机计时器汇编语言源程序
  • 51单片机制作的一个篮球计时与计分,其中包括了proteus仿真图和keil软件代码(c编写)
  • 51单片机用定时器做300s倒计时器,适用于初学者
  • 计时器能够实现篮球比赛单节12分钟计时的要求,键盘控制具有暂停计时和重新给分和秒重新置数的以及继续计时的功能,

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 554
精华内容 221
关键字:

51单片机计时器