STM51单片机学习记录（九）通过秒表项目学习通过定时器实现消抖

× 文章目录
  1. 1. 1.秒表项目简介
  2. 2. 2.修改独立按键C文件：Key.c
  3. 3. 2.修改数码管C文件：NiXie.c
  4. 4. 3.主函数编写

1.秒表项目简介

我们通过秒表这一项目完成通过定时器实现消抖的理解。

功能如下：

按独立按键1：开始/暂停计时。

按独立按键2：计时清零。

按独立按键3：把数据存至AT24C02。

按独立按键4：将AT24C02中的数据读出。


2.修改独立按键C文件：Key.c

先放出原先的Key.c文件内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <REGX52.H>
#include "Delay.h"

unsigned char Key()
{
	unsigned char KeyNum=0;
	if(P3_1==0){Delay(20);while(!P3_1)Delay(20);KeyNum=1;}
	if(P3_0==0){Delay(20);while(!P3_0)Delay(20);KeyNum=2;}
	if(P3_2==0){Delay(20);while(!P3_2)Delay(20);KeyNum=3;}
	if(P3_3==0){Delay(20);while(!P3_3)Delay(20);KeyNum=4;}
	
	return KeyNum;
}

我们可以看到，就像在《 STM51单片机学习记录（一)》中一样，可以通过在按键的前后加上Delay()函数实现消抖。但这样若长按按键会使程序陷入死循环。同时Delay()会对整个程序进行延时，在需要频繁检测按键变化时会占用大量的CPU资源。

因此，我们可以对Key.c文件进行改进，用定时器实现就是一个很好的思路。

我们的核心思路是复用定时中断，根据不同的定时时间触发不同的函数，以此实现类似“多个定时器”的效果。

下面是Key需要触发的中断，我们通过T0Count1进行计数，累计计数20次(每隔20ms)，触发一次Key_Loop()函数，并将T0Count1清零重新计数：

1
2
3
4
5
6
7
8
9
10
11
12
void Timer0_Routine() interrupt 1
{
	static unsigned int T0Count1,T0Count2,T0Count3;
	TL0 = 0x66;		//设置定时初值
	TH0 = 0xFC;		//设置定时初值
	T0Count1++;
	if(T0Count1>=20)//每隔20ms检测一次
	{
		T0Count1=0;
		Key_Loop();
	}
}

Key_Loop()函数如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void Key_Loop(){
	static unsigned char NowState,LastState;
	LastState=NowState;
	NowState=Key_GetState();
	if(LastState==1&&NowState==0){//上一个状态非0，现在为0，表示按键松手
		Key_KeyNumber=1;
	}
	if(LastState==2&&NowState==0){
		Key_KeyNumber=2;
	}
	if(LastState==3&&NowState==0){
		Key_KeyNumber=3;
	}
	if(LastState==4&&NowState==0){
		Key_KeyNumber=4;
	}
}

核心逻辑是：通过判断20ms前（LastState）与20ms后（NowState）的电平变化来判断当前的按键状态。

State=0表示按键接通，具体的关系如下：

如果LastState=0，NowState=0，表示按键未按下；

如果LastState=0，NowState=!0，表示按键刚按下；

如果LastState=!0，NowState!=0，表示按键一直被按下；

如果LastState=!0，NowState=0，表示按键刚放开；

“按键刚放开的状态”（LastState=!0，NowState=0）可以代表按键已经完成按下这一动作，我们通过Key_GetState()函数获得瞬时捕获的State状态。Key_GetState()由原来的Key()改写而来：

1
2
3
4
5
6
7
8
9
unsigned char Key_GetState()
{
	unsigned char KeyNum=0;
	if(P3_1==0){KeyNum=1;}
	if(P3_0==0){KeyNum=2;}
	if(P3_2==0){KeyNum=3;}
	if(P3_3==0){KeyNum=4;}
	return KeyNum;
}

写到这里，Key_KeyNumber其实已经可以代表正确的消抖后的返回值了，我们再写一个Key()函数返回即可：

1
2
3
4
5
6
unsigned char Key(){
	unsigned char temp=0;
	temp=Key_KeyNumber;
	Key_KeyNumber=0;
	return temp;
}

需要注意的是，我们不能直接return Key_KeyNumber，因为扫描是一直在进行的，每隔20msKey_KeyNumber就会更新一次。用一个例子来讲解：

独立按键1在20ms时刻被按下，在这之前Key_KeyNumber=0，按下后Key_KeyNumber=1。

若我们要判断60ms时按键的状态，按照实际情况，此时按键已经弹起，Key_KeyNumber应该=0，但由于再次调用时Key_KeyNumber没有重置，因此Key_KeyNumber仍然=1，与实际情况不符。

时刻 0 20 40 60 80 100
Key_KeyNumber 0 1 1 1 1 1

所以，我们每按一次就需要清零一次，可以用temp暂存一下，然后清零Key_KeyNumber，最终返回temp暂存的值。



2.修改数码管C文件：NiXie.c

先放出原先的NiXie.c文件内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <REGX52.H>
#include "Delay.h"


unsigned char NiXieTable[]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};

void NiXie(unsigned char location,number)
{
		switch(location)
		{
			case 1:P2_4=1;P2_3=1;P2_2=1;break;
			case 2:P2_4=1;P2_3=1;P2_2=0;break;
			case 3:P2_4=1;P2_3=0;P2_2=1;break;
			case 4:P2_4=1;P2_3=0;P2_2=0;break;
			case 5:P2_4=0;P2_3=1;P2_2=1;break;
			case 6:P2_4=0;P2_3=1;P2_2=0;break;
			case 7:P2_4=0;P2_3=0;P2_2=1;break;
			case 8:P2_4=0;P2_3=0;P2_2=0;break;
		}
		P0=NiXieTable[number];
		Delay(1);
		P0=0;
}

我们用数码管来实现秒表的动态计时变化。在原先的NiXie.c中，我们为了消影会在段选结束后Delay(1)，然后将P0置0。

出于同样的考量，我们选择用定时器实现同样的功能。

下面是NiXie需要触发的中断，我们通过T0Count2进行计数，累计计数2次(每隔2ms)，触发一次NiXie_Loop()函数，并将T0Count2清零重新计数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void Timer0_Routine() interrupt 1
{
	static unsigned int T0Count1,T0Count2,T0Count3;
	TL0 = 0x66;		//设置定时初值
	TH0 = 0xFC;		//设置定时初值
	T0Count1++;
	if(T0Count1>=20)//每隔20ms检测一次
	{
		T0Count1=0;
		Key_Loop();
	}
	T0Count2++;
	if(T0Count2>=2)//每隔2ms检测一次
	{
		T0Count2=0;
		NiXie_Loop();
	}
}

NiXie_Loop()函数如下：

1
2
3
4
5
6
void NiXie_Loop(void){//在中断函数中每隔2ms执行一次
	static unsigned char i=1;
	NiXie_Scan(i,NiXie_Buf[i]);//这里会每隔2ms向下扫描一位，总计16ms扫描完一轮8个数码管
	i++;
	if(i>8){i=1;}//i∈[1,8]
}

我们通过调用NiXie_Scan函数实现对每一位的扫描，在对应位上显示的数字由NiXie_Buf[i]控制。NiXie_Scan()由原来的NiXie()改写而来：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void NiXie_Scan(unsigned char location,number)
{
		P0=0x00;//消影
		switch(location)
		{
			case 1:P2_4=1;P2_3=1;P2_2=1;break;
			case 2:P2_4=1;P2_3=1;P2_2=0;break;
			case 3:P2_4=1;P2_3=0;P2_2=1;break;
			case 4:P2_4=1;P2_3=0;P2_2=0;break;
			case 5:P2_4=0;P2_3=1;P2_2=1;break;
			case 6:P2_4=0;P2_3=1;P2_2=0;break;
			case 7:P2_4=0;P2_3=0;P2_2=1;break;
			case 8:P2_4=0;P2_3=0;P2_2=0;break;
		}
		P0=NiXieTable[number];//这句执行完以后会过2ms再执行下一个NiXie_Scan。相当于Delay(2)
}

可以看到，我们去掉了Delay(1);,同时将P0=0x00;放到了函数开头，这是因为NiXie_Loop()通定时器实现了Delay的功能，而将P0=0x00;放到函数开头可以实现函数执行结束后延时的无缝对接。

我们对NiXieTable[]也做了一定修改，具体如下：

1
2
3
unsigned char NiXieTable[]={
0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F,0x00,0x40};
//0,1,2,3,4,5,6,7,8,NULL,-

NiXie_Buf[i]是我们想显示的数字与符号，我们先初始化：

1
unsigned char NiXie_Buf[9]={0,10,10,10,10,10,10,10,10};

NiXie_Buf长度为9是因为NiXie(i,NiXie_Buf[i])中的i∈[1,8]，下标范围为0~8方便直接调用。根据NiXieTable[]可知初始化为10表示清空数码管显示。

这样，我只需要再定义一个NiXie_SetBuf()函数用于设定第location位显示的数字为number，在主函数中调用NiXie_SetBuf()函数即可控制数码管显示。

1
2
3
void NiXie_SetBuf(unsigned char location,number){
	NiXie_Buf[location]=number;//设定第location位显示的数字为number
}


3.主函数编写

首先定义三个变量用于存放分、秒与百分秒：

1
unsigned char Min,Sec,MinSec;

再定义一个变量用于控制按键：

1
unsigned char KeyNum;

最后定义一个变量用于控制按键1的开始与暂停状态：

1
unsigned char RunFlag;

以上变量均为全局变量。

在主函数中，我们需要实现“真正”的计时功能，再次复用定时器中断：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
void Timer0_Routine() interrupt 1
{
	static unsigned int T0Count1,T0Count2,T0Count3;
	TL0 = 0x66;		//设置定时初值
	TH0 = 0xFC;		//设置定时初值
	T0Count1++;
	if(T0Count1>=20)//每隔20ms检测一次
	{
		T0Count1=0;
		Key_Loop();
	}
	T0Count2++;
	if(T0Count2>=2)//每隔2ms检测一次
	{
		T0Count2=0;
		NiXie_Loop();
	}
	T0Count3++;
	if(T0Count3>=10)//每隔10ms检测一次
	{
		T0Count3=0;
		Sec_Loop();
	}
}

Sec_Loop()函数用于控制时间的进位，具体代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void Sec_Loop(){
	if(RunFlag){//RunFlag=1时才计时
		MinSec++;
		if(MinSec>=100){//10ms扫描一次，100次相当于过了1s，进位
			MinSec=0;
			Sec++;
			if(Sec>=60){//进位
				Sec=0;
				Min++;
				if(Min>=60){//进位
					Min=0;
				}
			}
		}
	}
}

自此，所有的函数组件已经全部搭建完毕，main函数的编写就没有任何困难了：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
void main()
{

  Timer0_Init();
  while(1)
  {
		KeyNum=Key();
		if(KeyNum==1){
			RunFlag=!RunFlag;
		}
		if(KeyNum==2){
			Min=0;
			Sec=0;
			MinSec=0;
		}
		if(KeyNum==3){
			AT24C02_WriteByte(0,Min);
			Delay(5);
			AT24C02_WriteByte(1,Sec);
			Delay(5);
			AT24C02_WriteByte(2,MinSec);
			Delay(5);
		}
		if(KeyNum==4){
			Min=AT24C02_ReadByte(0);
			Sec=AT24C02_ReadByte(1);
			MinSec=AT24C02_ReadByte(2);
		}
		
		NiXie_SetBuf(1,Min/10);
		NiXie_SetBuf(2,Min%10);
		NiXie_SetBuf(3,11);
		NiXie_SetBuf(4,Sec/10);
		NiXie_SetBuf(5,Sec%10);
		NiXie_SetBuf(6,11);
		NiXie_SetBuf(7,MinSec/10);
		NiXie_SetBuf(8,MinSec%10);
	}
}

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

一只水獭<br>正在努力为猫獭鼠之家奋斗