从单片机基础到程序框架（连载）

单片机

ZHAOLH · 2017-12-8 10:43:49

继续顶下去！！！！！

徐俊华 · 2017-12-9 19:33:17

支持吴老师，学到了很多

吴坚鸿 · 2017-12-10 11:11:24

第九十九节： “行列扫描式”矩阵按键的单个触发（原始版）。

【99.1 “行列扫描式”矩阵按键。】


            上图99.1.1  有源蜂鸣器电路


            上图99.1.2  3*3矩阵按键的电路

   上图是3*3的矩阵按键电路，其它4*4或者8*8的矩阵电路原理是一样的，编程思路也是一样的。相对独立按键，矩阵按键因为采用动态行列扫描的方式，能更加节省IO口，比如3*3的3行3列，1行占用1根IO口，1列占用1根IO口，因此3*3矩阵按键占用6个IO口（3+3=6），但是能识别9个按键（3*3=9）。同理，8*8矩阵按键占用16个IO口（8+8=16），但是能识别64个按键（8*8=64）。
      矩阵按键的编程原理。如上图3*3矩阵按键的电路，行IO口（P2.2，P2.1，P2.0）定为输入，列IO口（P2.5，P2.4，P2.3）定为输出。同一时刻，列输出的3个IO口只能有1根是输出L（低电平），其它2根必须全是H（高电平），然后依次轮番切换输出状态，列输出每切换一次，就分别读取一次行输入的3个IO口，这样一次就能识别到3个按键的状态，如果列连续切换3次就可以读取全部9个按键的状态。列的3种输出状态分别是：（P2.5为L，P2.4为H，P2.3为H）,（P2.5为H，P2.4为L，P2.3为H）,（P2.5为H，P2.4为H，P2.3为L）。为什么列输出每切换一次就能识别到3个按键的状态？因为，首先要明白一个前提，在没有任何按键“被按下”的时候，行输入的3个IO口因为内部上拉电阻的作用，默认状态都是H电平。并且，H与H相互短接输出为H，H与L相互短接输出L，也就是，L（低电平）的优先级最大，任何H（高电平）碰到L（低电平）输出的结果都是L（低电平）。L（低电平）就像数学乘法运算里的数字0，任何数跟0相乘必然等于0。多说一句，这个“L最高优先级”法则是有前提的，就是H（高电平）的产生必须是纯粹靠上拉电阻拉高的H（高电平）才行，比如刚好本教程所用的51单片机内部IO口输出的H（高电平）是依靠内部的上拉电阻产生，如果是其它“非上拉电阻产生的高电平”与“低电平”短接就有“短路烧坏芯片”的风险，这时就需要额外增加“三极管开漏式输出”电路或者外挂“开漏式输出集成芯片”电路。继续回到正题，为什么列输出每切换一次就能识别到3个按键的状态？举个例子，比如当列输出状态处于（P2.5为L，P2.4为H，P2.3为H）下，我们读取行输入的P2.2口，行输入的P2.2与列输出P2.5，P2.4，P2.3的“交叉处”有3个按键S1，S2，S3，此时，如果P2.2口是L（低电平），那么必然是S1“被按下”，因为想让P2.2口是L，只有S1有这个能力，而如果S1没有“被按下”，另外两个S2，S3即使“被按下”，P2.2口也是H而绝对不会为L，因为S2，S3的列输出P2.4为H，P2.3为H，H与H相互短接输出的结果必然为H。
      本节例程实现的功能：9个矩阵按键，每按下1个按键都触发一次蜂鸣器鸣叫。

#include "REG52.H"
#define KEY_VOICE_TIME 50
#define KEY_SHORT_TIME 20 //按键去抖动的“滤波”时间
void T0_time();
void SystemInitial(void) ;
void Delay(unsigned long u32DelayTime) ;
void PeripheralInitial(void) ;
void BeepOpen(void);
void BeepClose(void);
void VoiceScan(void);
void KeyScan(void);
void KeyTask(void);
***it P3_4=P3^4; //蜂鸣器
***it ROW_INPUT1=P2^2; //第1行输入口。
***it ROW_INPUT2=P2^1; //第2行输入口。
***it ROW_INPUT3=P2^0; //第3行输入口。
***it COLUMN_OUTPUT1=P2^5; //第1列输出口。
***it COLUMN_OUTPUT2=P2^4; //第2列输出口。
***it COLUMN_OUTPUT3=P2^3; //第3列输出口。
volatile unsigned char vGu8BeepTimerFlag=0;
volatile unsigned int vGu16BeepTimerCnt=0;
volatile unsigned char vGu8KeySec=0; //按键的触发序号
void main()
{
SystemInitial();
Delay(10000);
PeripheralInitial();
while(1)
{
KeyTask(); //按键的任务函数
}
}
/* 注释一：
* 矩阵按键扫描的详细过程：
* 先输出某1列低电平，其它2列输出高电平，延时等待2ms后（等此3列输出同步稳定），
* 再分别判断3行的输入IO口，如果发现哪一行是低电平，就说明对应的某个按键被触发。
* 依次循环切换输出的3种状态，并且分别判断输入的3行，就可以检测完9个按键。矩阵按键的
* 去抖动处理方法跟我前面讲的独立按键去抖动方法是一样的，不再重复多讲。
*/
void KeyScan(void) //此函数放在定时中断里每1ms扫描一次
{
static unsigned char Su8KeyLock=0;
static unsigned int Su16KeyCnt=0;
static unsigned char Su8KeyStep=1;
switch(Su8KeyStep)
{
case 1: //按键扫描输出第一列低电平
COLUMN_OUTPUT1=0;
COLUMN_OUTPUT2=1;
COLUMN_OUTPUT3=1;
Su16KeyCnt=0; //延时计数器清零
Su8KeyStep++; //切换到下一个运行步骤
break;
case 2: //延时等待2ms后（等此3列输出同步稳定）。不是按键的去抖动延时。
Su16KeyCnt++;
if(Su16KeyCnt>=2)
{
Su16KeyCnt=0;
Su8KeyStep++; //切换到下一个运行步骤
}
break;
case 3:
if(1==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3)
{
Su8KeyStep++; //如果没有按键按下，切换到下一个运行步骤
Su8KeyLock=0; //按键自锁标志清零
Su16KeyCnt=0; //按键去抖动延时计数器清零，此行非常巧妙
}
else if(0==Su8KeyLock) //有按键按下，且是第一次触发
{
if(0==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3)
{
Su16KeyCnt++; //去抖动延时计数器
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su16KeyCnt=0;
Su8KeyLock=1;//自锁置1,避免一直触发,只有松开按键,此标志位才会被清零
vGu8KeySec=1; //触发1号键对应S1键
}
}
else if(1==ROW_INPUT1&&0==ROW_INPUT2&&1==ROW_INPUT3)
{
Su16KeyCnt++; //去抖动延时计数器
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su16KeyCnt=0;
Su8KeyLock=1;//自锁置1,避免一直触发,只有松开按键,此标志位才会被清零
vGu8KeySec=2; //触发2号键对应S2键
}
}
else if(1==ROW_INPUT1&&1==ROW_INPUT2&&0==ROW_INPUT3)
{
Su16KeyCnt++; //去抖动延时计数器
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su16KeyCnt=0;
Su8KeyLock=1;//自锁置1,避免一直触发,只有松开按键,此标志位才会被清零
vGu8KeySec=3; //触发3号键对应S3键
}
}
}
break;
case 4: //按键扫描输出第二列低电平
COLUMN_OUTPUT1=1;
COLUMN_OUTPUT2=0;
COLUMN_OUTPUT3=1;
Su16KeyCnt=0; //延时计数器清零
Su8KeyStep++; //切换到下一个运行步骤
break;
case 5: //延时等待2ms后（等此3列输出同步稳定）。不是按键的去抖动延时。
Su16KeyCnt++;
if(Su16KeyCnt>=2)
{
Su16KeyCnt=0;
Su8KeyStep++; //切换到下一个运行步骤
}
break;
case 6:
if(1==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3)
{
Su8KeyStep++; //如果没有按键按下，切换到下一个运行步骤
Su8KeyLock=0; //按键自锁标志清零
Su16KeyCnt=0; //按键去抖动延时计数器清零，此行非常巧妙
}
else if(0==Su8KeyLock) //有按键按下，且是第一次触发
{
if(0==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3)
{
Su16KeyCnt++; //去抖动延时计数器
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su16KeyCnt=0;
Su8KeyLock=1;//自锁置1,避免一直触发,只有松开按键,此标志位才会被清零
vGu8KeySec=4; //触发4号键对应S4键
}
}
else if(1==ROW_INPUT1&&0==ROW_INPUT2&&1==ROW_INPUT3)
{
Su16KeyCnt++; //去抖动延时计数器
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su16KeyCnt=0;
Su8KeyLock=1;//自锁置1,避免一直触发,只有松开按键,此标志位才会被清零
vGu8KeySec=5; //触发5号键对应S5键
}
}
else if(1==ROW_INPUT1&&1==ROW_INPUT2&&0==ROW_INPUT3)
{
Su16KeyCnt++; //去抖动延时计数器
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su16KeyCnt=0;
Su8KeyLock=1;//自锁置1,避免一直触发,只有松开按键,此标志位才会被清零
vGu8KeySec=6; //触发6号键对应S6键
}
}
}
break;
case 7: //按键扫描输出第三列低电平
COLUMN_OUTPUT1=1;
COLUMN_OUTPUT2=1;
COLUMN_OUTPUT3=0;
Su16KeyCnt=0; //延时计数器清零
Su8KeyStep++; //切换到下一个运行步骤
break;
case 8: //延时等待2ms后（等此3列输出同步稳定）。不是按键的去抖动延时。
Su16KeyCnt++;
if(Su16KeyCnt>=2)
{
Su16KeyCnt=0;
Su8KeyStep++; //切换到下一个运行步骤
}
break;
case 9:
if(1==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3)
{
Su8KeyStep=1; //如果没有按键按下，返回到第一步，重新开始扫描！！！！！！
Su8KeyLock=0; //按键自锁标志清零
Su16KeyCnt=0; //按键去抖动延时计数器清零，此行非常巧妙
}
else if(0==Su8KeyLock) //有按键按下，且是第一次触发
{
if(0==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3)
{
Su16KeyCnt++; //去抖动延时计数器
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su16KeyCnt=0;
Su8KeyLock=1;//自锁置1,避免一直触发,只有松开按键,此标志位才会被清零
vGu8KeySec=7; //触发7号键对应S7键
}
}
else if(1==ROW_INPUT1&&0==ROW_INPUT2&&1==ROW_INPUT3)
{
Su16KeyCnt++; //去抖动延时计数器
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su16KeyCnt=0;
Su8KeyLock=1;//自锁置1,避免一直触发,只有松开按键,此标志位才会被清零
vGu8KeySec=8; //触发8号键对应S8键
}
}
else if(1==ROW_INPUT1&&1==ROW_INPUT2&&0==ROW_INPUT3)
{
Su16KeyCnt++; //去抖动延时计数器
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su16KeyCnt=0;
Su8KeyLock=1;//自锁置1,避免一直触发,只有松开按键,此标志位才会被清零
vGu8KeySec=9; //触发9号键对应S9键
}
}
}
break;
}
}
void KeyTask(void) //按键任务函数，放在主函数内
{
if(0==vGu8KeySec)
{
return; //按键的触发序号是0意味着无按键触发，直接退出当前函数，不执行此函数下面的代码
}
switch(vGu8KeySec) //根据不同的按键触发序号执行对应的代码
{
case 1: //S1触发的任务
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //发出“嘀”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一直触发
break;
case 2: //S2触发的任务
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //发出“嘀”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一直触发
break;
case 3: //S3触发的任务
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //发出“嘀”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一直触发
break;
case 4: //S4触发的任务
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //发出“嘀”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一直触发
break;
case 5: //S5触发的任务
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //发出“嘀”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一直触发
break;
case 6: //S6触发的任务
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //发出“嘀”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一直触发
break;
case 7: //S7触发的任务
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //发出“嘀”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一直触发
break;
case 8: //S8触发的任务
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //发出“嘀”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一直触发
break;
case 9: //S9触发的任务
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //发出“嘀”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一直触发
break;
}
}
void T0_time() interrupt 1
{
VoiceScan();
KeyScan(); //按键识别的驱动函数
TH0=0xfc;
TL0=0x66;
}
void SystemInitial(void)
{
TMOD=0x01;
TH0=0xfc;
TL0=0x66;
EA=1;
ET0=1;
TR0=1;
}
void Delay(unsigned long u32DelayTime)
{
for(;u32DelayTime>0;u32DelayTime--);
}
void PeripheralInitial(void)
{
}
void BeepOpen(void)
{
P3_4=0;
}
void BeepClose(void)
{
P3_4=1;
}
void VoiceScan(void)
{
static unsigned char Su8Lock=0;
if(1==vGu8BeepTimerFlag&&vGu16BeepTimerCnt>0)
{
if(0==Su8Lock)
{
Su8Lock=1;
BeepOpen();
}
else
{
vGu16BeepTimerCnt--;
if(0==vGu16BeepTimerCnt)
{
Su8Lock=0;
BeepClose();
}
}
}
}

复制代码

ZHAOLH · 2017-12-12 10:02:12

又来！！！！！！！！！！！！！1

刘 · 2017-12-12 16:33:03

谢谢分享

吴坚鸿 · 2017-12-17 11:32:11

第一百节： “行列扫描式”矩阵按键的单个触发（优化版）。

【100.1 “行列扫描式”矩阵按键。】


            上图100.1.1  有源蜂鸣器电路

            上图100.1.2  3*3矩阵按键的电路

   写程序，凡是出现“重复性、相似性”的代码，都可以加入“循环，判断，数组”这类语句对代码进行压缩优化。上一节讲的矩阵按键，代码是记流水账式的，出现很多“重复性、相似性”的代码，是没有经过优化的“原始版”，本节的目的是对上一节的代码进行优化，让大家从中发现一些技巧。
   多说一句，我一直认为，只要单片机容量够，代码多一点少一点并不重要，只要不影响运行效率就行。而且有时候，代码写多一点，可读性非常强，修改起来也非常方便。如果一味的追求压缩代码，就会刻意用很多“循环，判断，数组”等元素，代码虽然紧凑了，但是可分离性，可更改性，可阅读性就没那么强。因此，做项目的时候，某些代码要不要进行压缩，是没有绝对标准的，能因敌而取胜者谓之神。
   本节例程实现的功能：9个矩阵按键，每按下1个按键都触发一次蜂鸣器鸣叫。

#include "REG52.H"
#define KEY_VOICE_TIME 50
#define KEY_SHORT_TIME 20 //按键去抖动的“滤波”时间
void T0_time();
void SystemInitial(void) ;
void Delay(unsigned long u32DelayTime) ;
void PeripheralInitial(void) ;
void BeepOpen(void);
void BeepClose(void);
void VoiceScan(void);
void KeyScan(void);
void KeyTask(void);
***it P3_4=P3^4; //蜂鸣器
***it ROW_INPUT1=P2^2; //第1行输入口。
***it ROW_INPUT2=P2^1; //第2行输入口。
***it ROW_INPUT3=P2^0; //第3行输入口。
***it COLUMN_OUTPUT1=P2^5; //第1列输出口。
***it COLUMN_OUTPUT2=P2^4; //第2列输出口。
***it COLUMN_OUTPUT3=P2^3; //第3列输出口。
volatile unsigned char vGu8BeepTimerFlag=0;
volatile unsigned int vGu16BeepTimerCnt=0;
volatile unsigned char vGu8KeySec=0; //按键的触发序号
void main()
{
SystemInitial();
Delay(10000);
PeripheralInitial();
while(1)
{
KeyTask(); //按键的任务函数
}
}
/* 注释一：
* 矩阵按键扫描的详细过程：
* 先输出某1列低电平，其它2列输出高电平，延时等待2ms后（等此3列输出同步稳定），
* 再分别判断3行的输入IO口，如果发现哪一行是低电平，就说明对应的某个按键被触发。
* 依次循环切换输出的3种状态，并且分别判断输入的3行，就可以检测完9个按键。矩阵按键的
* 去抖动处理方法跟我前面讲的独立按键去抖动方法是一样的，不再重复多讲。
*/
void KeyScan(void) //此函数放在定时中断里每1ms扫描一次
{
static unsigned char Su8KeyLock=0;
static unsigned int Su16KeyCnt=0;
static unsigned char Su8KeyStep=1;
static unsigned char Su8ColumnRecord=0; //本节多增加此变量用来切换当前列的输出
switch(Su8KeyStep)
{
case 1:
if(0==Su8ColumnRecord) //按键扫描输出第一列低电平
{
COLUMN_OUTPUT1=0;
COLUMN_OUTPUT2=1;
COLUMN_OUTPUT3=1;
}
else if(1==Su8ColumnRecord) //按键扫描输出第二列低电平
{
COLUMN_OUTPUT1=1;
COLUMN_OUTPUT2=0;
COLUMN_OUTPUT3=1;
}
else //按键扫描输出第三列低电平
{
COLUMN_OUTPUT1=1;
COLUMN_OUTPUT2=1;
COLUMN_OUTPUT3=0;
}
Su16KeyCnt=0; //延时计数器清零
Su8KeyStep++; //切换到下一个运行步骤
break;
case 2: //延时等待2ms后（等此3列输出同步稳定）。不是按键的去抖动延时。
Su16KeyCnt++;
if(Su16KeyCnt>=2)
{
Su16KeyCnt=0;
Su8KeyStep++; //切换到下一个运行步骤
}
break;
case 3:
if(1==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3)
{
Su8KeyStep=1; //如果没有按键按下，返回到第一个运行步骤重新开始扫描!!!!!!
Su8KeyLock=0; //按键自锁标志清零
Su16KeyCnt=0; //按键去抖动延时计数器清零，此行非常巧妙
Su8ColumnRecord++; //输出下一列
if(Su8ColumnRecord>=3)
{
Su8ColumnRecord=0; //依次输出完第3列之后，继续从第1列开始输出低电平
}
}
else if(0==Su8KeyLock) //有按键按下，且是第一次触发
{
if(0==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3)
{
Su16KeyCnt++; //去抖动延时计数器
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su16KeyCnt=0;
Su8KeyLock=1;//自锁置1,避免一直触发,只有松开按键,此标志位才会被清零
if(0==Su8ColumnRecord) //第1列输出低电平
{
vGu8KeySec=1; //触发1号键对应S1键
}
else if(1==Su8ColumnRecord) //第2列输出低电平
{
vGu8KeySec=2; //触发2号键对应S2键
}
else if(2==Su8ColumnRecord) //第3列输出低电平
{
vGu8KeySec=3; //触发3号键对应S3键
}
}
}
else if(1==ROW_INPUT1&&0==ROW_INPUT2&&1==ROW_INPUT3)
{
Su16KeyCnt++; //去抖动延时计数器
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su16KeyCnt=0;
Su8KeyLock=1;//自锁置1,避免一直触发,只有松开按键,此标志位才会被清零
if(0==Su8ColumnRecord) //第1列输出低电平
{
vGu8KeySec=4; //触发4号键对应S4键
}
else if(1==Su8ColumnRecord) //第2列输出低电平
{
vGu8KeySec=5; //触发5号键对应S5键
}
else if(2==Su8ColumnRecord) //第3列输出低电平
{
vGu8KeySec=6; //触发6号键对应S6键
}
}
}
else if(1==ROW_INPUT1&&1==ROW_INPUT2&&0==ROW_INPUT3)
{
Su16KeyCnt++; //去抖动延时计数器
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su16KeyCnt=0;
Su8KeyLock=1;//自锁置1,避免一直触发,只有松开按键,此标志位才会被清零
if(0==Su8ColumnRecord) //第1列输出低电平
{
vGu8KeySec=7; //触发7号键对应S7键
}
else if(1==Su8ColumnRecord) //第2列输出低电平
{
vGu8KeySec=8; //触发8号键对应S8键
}
else if(2==Su8ColumnRecord) //第3列输出低电平
{
vGu8KeySec=9; //触发9号键对应S9键
}
}
}
}
break;
}
}
void KeyTask(void) //按键任务函数，放在主函数内
{
if(0==vGu8KeySec)
{
return; //按键的触发序号是0意味着无按键触发，直接退出当前函数，不执行此函数下面的代码
}
switch(vGu8KeySec) //根据不同的按键触发序号执行对应的代码
{
case 1: //S1触发的任务
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //发出“嘀”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一直触发
break;
case 2: //S2触发的任务
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //发出“嘀”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一直触发
break;
case 3: //S3触发的任务
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //发出“嘀”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一直触发
break;
case 4: //S4触发的任务
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //发出“嘀”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一直触发
break;
case 5: //S5触发的任务
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //发出“嘀”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一直触发
break;
case 6: //S6触发的任务
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //发出“嘀”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一直触发
break;
case 7: //S7触发的任务
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //发出“嘀”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一直触发
break;
case 8: //S8触发的任务
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //发出“嘀”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一直触发
break;
case 9: //S9触发的任务
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //发出“嘀”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一直触发
break;
}
}
void T0_time() interrupt 1
{
VoiceScan();
KeyScan(); //按键识别的驱动函数
TH0=0xfc;
TL0=0x66;
}
void SystemInitial(void)
{
TMOD=0x01;
TH0=0xfc;
TL0=0x66;
EA=1;
ET0=1;
TR0=1;
}
void Delay(unsigned long u32DelayTime)
{
for(;u32DelayTime>0;u32DelayTime--);
}
void PeripheralInitial(void)
{
}
void BeepOpen(void)
{
P3_4=0;
}
void BeepClose(void)
{
P3_4=1;
}
void VoiceScan(void)
{
static unsigned char Su8Lock=0;
if(1==vGu8BeepTimerFlag&&vGu16BeepTimerCnt>0)
{
if(0==Su8Lock)
{
Su8Lock=1;
BeepOpen();
}
else
{
vGu16BeepTimerCnt--;
if(0==vGu16BeepTimerCnt)
{
Su8Lock=0;
BeepClose();
}
}
}
}

复制代码

ZHAOLH · 2017-12-25 09:19:16

跟着楼主走！！！！！！！！！！！！！

孟庆禹 · 2017-12-26 23:07:40

感谢分享，从程序风格赏析帖子，到程序框架，一直关注

王云 · 2017-12-27 19:44:32

好久没有来了，鸿哥牛逼！

吴坚鸿 · 2017-12-31 16:44:25

第一百零一节：矩阵按键鼠标式的单击与双击。

【101.1 矩阵按键鼠标式的单击与双击。】


            上图101.1.1  有源蜂鸣器电路

            上图101.1.2  LED电路


            上图101.1.3  3*3矩阵按键的电路

      矩阵按键与前面章节独立按键的单击与双击的处理思路是一样的，本节讲矩阵按键的单击与双击，也算是重温之前章节讲的内容。
      鼠标的左键，可以触发单击，也可以触发双击。双击的规则是这样的，两次单击，如果第1次单击与第2次单击的时间比较“短”的时候，则这两次单击就构成双击。编写这个程序的最大亮点是如何控制好第1次单击与第2次单击的时间间隔。程序例程要实现的功能是：以S1按键为例，（1）单击改变LED灯的显示状态。单击一次LED从原来“灭”的状态变成“亮”的状态，或者从原来“亮”的状态变成“灭”的状态，依次循环切换。（2）双击则蜂鸣器发出“嘀”的一声。代码如下：

#include "REG52.H"
#define KEY_VOICE_TIME 50
#define KEY_SHORT_TIME 20 //按键去抖动的“滤波”时间
#define KEY_INTERVAL_TIME 80 //连续两次单击之间的最大有效时间。因为是矩阵，80不一定是80ms
void T0_time();
void SystemInitial(void) ;
void Delay(unsigned long u32DelayTime) ;
void PeripheralInitial(void) ;
void BeepOpen(void);
void BeepClose(void);
void LedOpen(void);
void LedClose(void);
void VoiceScan(void);
void KeyScan(void);
void SingleKeyTask(void); //单击按键任务函数，放在主函数内
void DoubleKeyTask(void); //双击按键任务函数，放在主函数内
***it P3_4=P3^4; //蜂鸣器
***it P1_4=P1^4; //LED
***it ROW_INPUT1=P2^2; //第1行输入口。
***it ROW_INPUT2=P2^1; //第2行输入口。
***it ROW_INPUT3=P2^0; //第3行输入口。
***it COLUMN_OUTPUT1=P2^5; //第1列输出口。
***it COLUMN_OUTPUT2=P2^4; //第2列输出口。
***it COLUMN_OUTPUT3=P2^3; //第3列输出口。
volatile unsigned char vGu8BeepTimerFlag=0;
volatile unsigned int vGu16BeepTimerCnt=0;
unsigned char Gu8LedStatus=0; //记录LED灯的状态，0代表灭，1代表亮
volatile unsigned char vGu8SingleKeySec=0; //单击按键的触发序号
volatile unsigned char vGu8DoubleKeySec=0; //双击按键的触发序号
void main()
{
SystemInitial();
Delay(10000);
PeripheralInitial();
while(1)
{
SingleKeyTask(); //单击按键任务函数
DoubleKeyTask(); //双击按键任务函数
}
}
/* 注释一：
* 矩阵按键扫描的详细过程：
* 先输出某1列低电平，其它2列输出高电平，延时等待2ms后（等此3列输出同步稳定），
* 再分别判断3行的输入IO口，如果发现哪一行是低电平，就说明对应的某个按键被触发。
* 依次循环切换输出的3种状态，并且分别判断输入的3行，就可以检测完9个按键。矩阵按键的
* 去抖动处理方法跟我前面讲的独立按键去抖动方法是一样的。
*/
/* 注释二：
* 双击按键扫描的详细过程：
* 第一步：平时没有按键被触发时，按键的自锁标志,去抖动延时计数器一直被清零。
* 如果之前已经有按键触发过1次单击，那么启动时间间隔计数器Su16KeyIntervalCnt1，
* 在KEY_INTERVAL_TIME这个允许的时间差范围内，如果一直没有第2次单击触发，
* 则把累加按键触发的次数Su8KeyTouchCnt1也清零，上一次累计的单击数被清零，
* 就意味着下一次新的双击必须重新开始累加两次单击数。
* 第二步：一旦有按键被按下，去抖动延时计数器开始在定时中断函数里累加，在还没累加到
* 阀值KEY_SHORT_TIME时，如果在这期间由于受外界干扰或者按键抖动，而使
* IO口突然瞬间触发成高电平，这个时候马上把延时计数器Su16KeyCnt
* 清零了,这个过程非常巧妙，非常有效地去除瞬间的杂波干扰，以后凡是用到开关感应器的时候，
* 都可以用类似这样的方法去干扰。
* 第三步：如果按键按下的时间超过了阀值KEY_SHORT_TIME，马上把自锁标志Su8KeyLock置1，
* 防止按住按键不松手后一直触发。与此同时，累加1次按键次数，如果按键次数累加有2次，
* 则认为触发双击按键，并把编号vGu8DoubleKeySec赋值。
* 第四步：等按键松开后，自锁标志Su8KeyLock及时清零解锁，为下一次自锁做准备。并且累加间隔时间，
* 防止两次按键的间隔时间太长。如果连续2次单击的间隔时间太长达到了KEY_INTERVAL_TIME
* 的长度，立即清零当前按键次数的计数器，这样意味着上一次的累加单击数无效，下一次双击
* 必须重新累加新的单击数。
*/
void KeyScan(void) //此函数放在定时中断里每1ms扫描一次
{
static unsigned char Su8KeyLock=0;
static unsigned int Su16KeyCnt=0;
static unsigned char Su8KeyStep=1;
static unsigned char Su8ColumnRecord=0; //用来切换当前列的输出
static unsigned char Su8KeyTouchCnt1; //S1按键的次数记录
static unsigned int Su16KeyIntervalCnt1; //S1按键的间隔时间计数器
switch(Su8KeyStep)
{
case 1:
if(0==Su8ColumnRecord) //按键扫描输出第一列低电平
{
COLUMN_OUTPUT1=0;
COLUMN_OUTPUT2=1;
COLUMN_OUTPUT3=1;
}
else if(1==Su8ColumnRecord) //按键扫描输出第二列低电平
{
COLUMN_OUTPUT1=1;
COLUMN_OUTPUT2=0;
COLUMN_OUTPUT3=1;
}
else //按键扫描输出第三列低电平
{
COLUMN_OUTPUT1=1;
COLUMN_OUTPUT2=1;
COLUMN_OUTPUT3=0;
}
Su16KeyCnt=0; //延时计数器清零
Su8KeyStep++; //切换到下一个运行步骤
break;
case 2: //延时等待2ms后（等此3列输出同步稳定）。不是按键的去抖动延时。
Su16KeyCnt++;
if(Su16KeyCnt>=2)
{
Su16KeyCnt=0;
Su8KeyStep++; //切换到下一个运行步骤
}
break;
case 3:
if(1==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3)
{
Su8KeyStep=1; //如果没有按键按下，返回到第一个运行步骤重新开始扫描!!!!!!
Su8KeyLock=0; //按键自锁标志清零
Su16KeyCnt=0; //按键去抖动延时计数器清零，此行非常巧妙
if(Su8KeyTouchCnt1>=1) //之前已经有按键触发过一次，启动间隔时间的计数器
{
Su16KeyIntervalCnt1++; //按键间隔的时间计数器累加
if(Su16KeyIntervalCnt1>=KEY_INTERVAL_TIME) //达到最大允许的间隔时间，溢出无效
{
Su16KeyIntervalCnt1=0; //时间计数器清零
Su8KeyTouchCnt1=0; //清零按键的按下的次数，因为间隔时间溢出无效
}
}
Su8ColumnRecord++; //输出下一列
if(Su8ColumnRecord>=3)
{
Su8ColumnRecord=0; //依次输出完第3列之后，继续从第1列开始输出低电平
}
}
else if(0==Su8KeyLock) //有按键按下，且是第一次触发
{
if(0==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3)
{
Su16KeyCnt++; //去抖动延时计数器
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su8KeyLock=1;//自锁置1,避免一直触发,只有松开按键,此标志位才会被清零
if(0==Su8ColumnRecord) //第1列输出低电平
{
Su16KeyIntervalCnt1=0; //按键有效间隔的时间计数器清零
Su8KeyTouchCnt1++; //记录当前单击的次数
if(1==Su8KeyTouchCnt1) //只按了1次
{
vGu8SingleKeySec=1; //单击任务，触发1号键对应S1键
}
else if(Su8KeyTouchCnt1>=2) //连续按了两次以上
{
Su8KeyTouchCnt1=0; //统计按键次数清零
vGu8SingleKeySec=1; //单击任务，触发1号键对应S1键
vGu8DoubleKeySec=1; //双击任务，触发1号键对应S1键
}
}
else if(1==Su8ColumnRecord) //第2列输出低电平
{
vGu8SingleKeySec=2; //触发2号键对应S2键
}
else if(2==Su8ColumnRecord) //第3列输出低电平
{
vGu8SingleKeySec=3; //触发3号键对应S3键
}
}
}
else if(1==ROW_INPUT1&&0==ROW_INPUT2&&1==ROW_INPUT3)
{
Su16KeyCnt++; //去抖动延时计数器
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su8KeyLock=1;//自锁置1,避免一直触发,只有松开按键,此标志位才会被清零
if(0==Su8ColumnRecord) //第1列输出低电平
{
vGu8SingleKeySec=4; //触发4号键对应S4键
}
else if(1==Su8ColumnRecord) //第2列输出低电平
{
vGu8SingleKeySec=5; //触发5号键对应S5键
}
else if(2==Su8ColumnRecord) //第3列输出低电平
{
vGu8SingleKeySec=6; //触发6号键对应S6键
}
}
}
else if(1==ROW_INPUT1&&1==ROW_INPUT2&&0==ROW_INPUT3)
{
Su16KeyCnt++; //去抖动延时计数器
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su8KeyLock=1;//自锁置1,避免一直触发,只有松开按键,此标志位才会被清零
if(0==Su8ColumnRecord) //第1列输出低电平
{
vGu8SingleKeySec=7; //触发7号键对应S7键
}
else if(1==Su8ColumnRecord) //第2列输出低电平
{
vGu8SingleKeySec=8; //触发8号键对应S8键
}
else if(2==Su8ColumnRecord) //第3列输出低电平
{
vGu8SingleKeySec=9; //触发9号键对应S9键
}
}
}
}
break;
}
}
void SingleKeyTask(void) //按键单击的任务函数，放在主函数内
{
if(0==vGu8SingleKeySec)
{
return; //按键的触发序号是0意味着无按键触发，直接退出当前函数，不执行此函数下面的代码
}
switch(vGu8SingleKeySec) //根据不同的按键触发序号执行对应的代码
{
case 1: //S1按键的单击任务
//通过Gu8LedStatus的状态切换，来反复切换LED的“灭”与“亮”的状态
if(0==Gu8LedStatus)
{
Gu8LedStatus=1; //标识并且更改当前LED灯的状态。0就变成1。
LedOpen(); //点亮LED
}
else
{
Gu8LedStatus=0; //标识并且更改当前LED灯的状态。1就变成0。
LedClose(); //关闭LED
}
vGu8SingleKeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一直触发
break;
default: //其它按键触发的单击
vGu8SingleKeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一直触发
break;
}
}
void DoubleKeyTask(void) //双击按键任务函数，放在主函数内
{
if(0==vGu8DoubleKeySec)
{
return; //按键的触发序号是0意味着无按键触发，直接退出当前函数，不执行此函数下面的代码
}
switch(vGu8DoubleKeySec) //根据不同的按键触发序号执行对应的代码
{
case 1: //S1按键的双击任务
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //触发双击后，发出“嘀”一声
vGu8BeepTimerFlag=1;
vGu8DoubleKeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一致触发
break;
}
}
void T0_time() interrupt 1
{
VoiceScan();
KeyScan(); //按键识别的驱动函数
TH0=0xfc;
TL0=0x66;
}
void SystemInitial(void)
{
TMOD=0x01;
TH0=0xfc;
TL0=0x66;
EA=1;
ET0=1;
TR0=1;
}
void Delay(unsigned long u32DelayTime)
{
for(;u32DelayTime>0;u32DelayTime--);
}
void PeripheralInitial(void)
{
/* 注释三：
* 把LED的初始化放在PeripheralInitial而不是放在SystemInitial，是因为LED显示内容对上电
* 瞬间的要求不高。但是，如果是控制继电器，则应该把继电器的输出初始化放在SystemInitial。
*/
//根据Gu8LedStatus的值来初始化LED当前的显示状态，0代表灭，1代表亮
if(0==Gu8LedStatus)
{
LedClose(); //关闭LED
}
else
{
LedOpen(); //点亮LED
}
}
void BeepOpen(void)
{
P3_4=0;
}
void BeepClose(void)
{
P3_4=1;
}
void LedOpen(void)
{
P1_4=0;
}
void LedClose(void)
{
P1_4=1;
}
void VoiceScan(void)
{
static unsigned char Su8Lock=0;
if(1==vGu8BeepTimerFlag&&vGu16BeepTimerCnt>0)
{
if(0==Su8Lock)
{
Su8Lock=1;
BeepOpen();
}
else
{
vGu16BeepTimerCnt--;
if(0==vGu16BeepTimerCnt)
{
Su8Lock=0;
BeepClose();
}
}
}
}

复制代码

ZHAOLH · 2018-1-5 09:33:55

继续顶帖！！！！！！！！！！！1

吴坚鸿 · 2018-1-7 12:27:47

第一百零二节：两个“任意行输入”矩阵按键的“有序”组合触发。

【102.1 “异行输入”“同行输入”“有序”。】


            上图102.1.1  有源蜂鸣器电路


            上图102.1.2  LED电路


            上图102.1.3  3*3矩阵按键的电路

   “任意行输入”是指能兼容“异行输入”与“同行输入”这两种按键状态。
      何谓“异行输入”何谓“同行输入”？如上图矩阵按键，P2.2，P2.1，P2.0是输入行，P2.5，P2.4，P2.3是输出列。以S1按键为例，很明显，S2和S3都是属于S1的“同行输入”，都是属于P2.2的输入行。除了S2和S3以外，其它所有的按键都是S1的“异行输入”，比如S5按键就是S1的“异行输入”，因为S1是属于P2.2的输入行，而S5是属于P2.1的输入行。
何谓“有序”组合触发？就是两个按键的触发必须遵守“先后顺序”才能构成“组合触发”。比如，像电脑的复制快捷键（Ctrl+C），你必须先按住Ctrl再按住C此时“复制快捷键”才有效，如果你先按住C再按住Ctrl此时“复制快捷键”无效。
   “异行输入”与“同行输入”，相比之下，“同行输入”更难更有代表性，如果把“同行输入”的程序写出来了，那么完全按“同行输入”的思路，就可以把“异行输入”的程序写出来。因此，只要把“同行输入”的程序写出来了，也就意味着“任意行输入”的程序也就实现了。本节以S1和S2的“同行输入”按键为例，S1是主键，类似复制快捷键的Ctrl键；S2是从键，类似复制快捷键的C键。要触发组合键（S1+S2），必须先按住S1再按S2才有效。功能如下：（1）S1每单击一次，LED要么从“灭”变成“亮”，要么从“亮”变成“灭”，在两种状态之间切换。（2）如果先按住S1再按S2，就认为构造了“有序”组合键，蜂鸣器发出“嘀”的一声。

#include "REG52.H"
#define KEY_VOICE_TIME 50
#define KEY_SHORT_TIME 20
void T0_time();
void SystemInitial(void) ;
void Delay(unsigned long u32DelayTime) ;
void PeripheralInitial(void) ;
void BeepOpen(void);
void BeepClose(void);
void LedOpen(void);
void LedClose(void);
void VoiceScan(void);
void KeyScan(void);
void SingleKeyTask(void);
void DoubleKeyTask(void);
***it P3_4=P3^4;
***it P1_4=P1^4;
***it ROW_INPUT1=P2^2; //第1行输入口。
***it ROW_INPUT2=P2^1; //第2行输入口。
***it ROW_INPUT3=P2^0; //第3行输入口。
***it COLUMN_OUTPUT1=P2^5; //第1列输出口。
***it COLUMN_OUTPUT2=P2^4; //第2列输出口。
***it COLUMN_OUTPUT3=P2^3; //第3列输出口。
volatile unsigned char vGu8BeepTimerFlag=0;
volatile unsigned int vGu16BeepTimerCnt=0;
unsigned char Gu8LedStatus=0;
volatile unsigned char vGu8SingleKeySec=0;
volatile unsigned char vGu8DoubleKeySec=0;
void main()
{
SystemInitial();
Delay(10000);
PeripheralInitial();
while(1)
{
SingleKeyTask();
DoubleKeyTask();
}
}
/* 注释一：
* 两个“任意行输入”矩阵按键“有序”触发的两个最关键地方：
* （1）当S1按键被按下单击触发之后， “马上更新输出列的信号状态”，然后切换到后面的步骤。
* （2）在后面的步骤里，进入到S1和S2两个按键的轮番循环监控之中，如果发现S1按键率先
* 被松开了，就把步骤切换到开始的第一步，重新开始新一轮的按键扫描。
* （3）按照这个模板，只需“更改不同的列输出，判断不同的行输入”，就可以实现“任意行输入”
* 矩阵按键的“有序”组合触发。
*/
void KeyScan(void) //此函数放在定时中断里每1ms扫描一次
{
static unsigned char Su8KeyLock=0;
static unsigned int Su16KeyCnt=0;
static unsigned char Su8KeyStep=1;
static unsigned char Su8ColumnRecord=0;
switch(Su8KeyStep)
{
case 1:
if(0==Su8ColumnRecord)
{
COLUMN_OUTPUT1=0;
COLUMN_OUTPUT2=1;
COLUMN_OUTPUT3=1;
}
else if(1==Su8ColumnRecord)
{
COLUMN_OUTPUT1=1;
COLUMN_OUTPUT2=0;
COLUMN_OUTPUT3=1;
}
else
{
COLUMN_OUTPUT1=1;
COLUMN_OUTPUT2=1;
COLUMN_OUTPUT3=0;
}
Su16KeyCnt=0;
Su8KeyStep++;
break;
case 2: //等待列输出稳定，但不是去抖动延时
Su16KeyCnt++;
if(Su16KeyCnt>=2)
{
Su16KeyCnt=0;
Su8KeyStep++;
}
break;
case 3:
if(1==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3)
{
Su8KeyStep=1;
Su8KeyLock=0;
Su16KeyCnt=0;
Su8ColumnRecord++;
if(Su8ColumnRecord>=3)
{
Su8ColumnRecord=0;
}
}
else if(0==Su8KeyLock)
{
if(0==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3)
{
Su16KeyCnt++;
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su8KeyLock=1;
if(0==Su8ColumnRecord)
{
vGu8SingleKeySec=1; //单击任务，触发1号键对应S1键
//“马上更新输出列的信号状态”
COLUMN_OUTPUT1=1;
COLUMN_OUTPUT2=0; //列2也输出0，非常关键的代码!
COLUMN_OUTPUT3=1;
Su16KeyCnt=0; //去抖动延时清零，为下一步计时做准备
Su8KeyStep++; //切换到下一步步骤
}
else if(1==Su8ColumnRecord)
{
vGu8SingleKeySec=2;
}
else if(2==Su8ColumnRecord)
{
vGu8SingleKeySec=3;
}
}
}
else if(1==ROW_INPUT1&&0==ROW_INPUT2&&1==ROW_INPUT3)
{
Su16KeyCnt++;
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su8KeyLock=1;
if(0==Su8ColumnRecord)
{
vGu8SingleKeySec=4;
}
else if(1==Su8ColumnRecord)
{
vGu8SingleKeySec=5;
}
else if(2==Su8ColumnRecord)
{
vGu8SingleKeySec=6;
}
}
}
else if(1==ROW_INPUT1&&1==ROW_INPUT2&&0==ROW_INPUT3)
{
Su16KeyCnt++;
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su8KeyLock=1;
if(0==Su8ColumnRecord)
{
vGu8SingleKeySec=7;
}
else if(1==Su8ColumnRecord)
{
vGu8SingleKeySec=8;
}
else if(2==Su8ColumnRecord)
{
vGu8SingleKeySec=9;
}
}
}
}
break;
case 4: //等待列输出稳定，但不是去抖动延时
Su16KeyCnt++;
if(Su16KeyCnt>=2)
{
Su16KeyCnt=0;
Su8KeyLock=0; //关键语句！自锁清零，为下一步自锁组合按键做准备
Su8KeyStep++;
}
break;
case 5: //判断S2按键
if(1==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3) //S2按键没有被按下
{
Su8KeyLock=0;
Su16KeyCnt=0;
//“马上更新输出列的信号状态”
COLUMN_OUTPUT1=0; //列1输出0，非常关键的代码!
COLUMN_OUTPUT2=1;
COLUMN_OUTPUT3=1;
Su8KeyStep++; //切换到下一个步骤，监控S1是否率先已经松开
}
else if(0==Su8KeyLock)
{
if(0==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3) //S2按键被按下
{
Su16KeyCnt++;
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su8KeyLock=1; //组合按键的自锁
vGu8DoubleKeySec=1; //触发组合按键(S1+S2)
}
}
}
break;
case 6: //等待列输出稳定，但不是去抖动延时
Su16KeyCnt++;
if(Su16KeyCnt>=2)
{
Su16KeyCnt=0;
Su8KeyLock=0; //关键语句！自锁清零，为下一步自锁组合按键做准备
Su8KeyStep++;
}
break;
case 7: //监控S1按键是否率先已经松开
if(1==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3)
{
Su16KeyCnt=0;
Su8KeyLock=0;
Su8KeyStep=1; //如果S1按键已经松开，返回到第一个运行步骤重新开始扫描
Su8ColumnRecord++;
if(Su8ColumnRecord>=3)
{
Su8ColumnRecord=0;
}
}
else
{
//“马上更新输出列的信号状态”
COLUMN_OUTPUT1=1;
COLUMN_OUTPUT2=0; //列2输出0，非常关键的代码!
COLUMN_OUTPUT3=1;
Su8KeyStep=4; //如果S1按键没有松开，继续返回判断S2是否已按下
}
break;
}
}
void SingleKeyTask(void)
{
if(0==vGu8SingleKeySec)
{
return;
}
switch(vGu8SingleKeySec)
{
case 1: //S1按键的单击任务，更改LED灯的显示状态
if(0==Gu8LedStatus)
{
Gu8LedStatus=1;
LedOpen();
}
else
{
Gu8LedStatus=0;
LedClose();
}
vGu8SingleKeySec=0;
break;
default:
vGu8SingleKeySec=0;
break;
}
}
void DoubleKeyTask(void)
{
if(0==vGu8DoubleKeySec)
{
return;
}
switch(vGu8DoubleKeySec)
{
case 1: //S1与S2的组合按键触发，发出“嘀”一声
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME;
vGu8BeepTimerFlag=1;
vGu8DoubleKeySec=0;
break;
}
}
void T0_time() interrupt 1
{
VoiceScan();
KeyScan();
TH0=0xfc;
TL0=0x66;
}
void SystemInitial(void)
{
TMOD=0x01;
TH0=0xfc;
TL0=0x66;
EA=1;
ET0=1;
TR0=1;
}
void Delay(unsigned long u32DelayTime)
{
for(;u32DelayTime>0;u32DelayTime--);
}
void PeripheralInitial(void)
{
if(0==Gu8LedStatus)
{
LedClose();
}
else
{
LedOpen();
}
}
void BeepOpen(void)
{
P3_4=0;
}
void BeepClose(void)
{
P3_4=1;
}
void LedOpen(void)
{
P1_4=0;
}
void LedClose(void)
{
P1_4=1;
}
void VoiceScan(void)
{
static unsigned char Su8Lock=0;
if(1==vGu8BeepTimerFlag&&vGu16BeepTimerCnt>0)
{
if(0==Su8Lock)
{
Su8Lock=1;
BeepOpen();
}
else
{
vGu16BeepTimerCnt--;
if(0==vGu16BeepTimerCnt)
{
Su8Lock=0;
BeepClose();
}
}
}
}

复制代码

ZHAOLH · 2018-1-8 10:00:34

顶楼主的坚持！！！！！！！！

莫家良 · 2018-1-12 12:36:30

谢谢收藏了！！！！

吴坚鸿 · 2018-1-14 10:34:49

第一百零三节：两个“任意行输入”矩阵按键的“无序”组合触发。

【103.1 “无序”组合触发。】


            上图103.1.1  有源蜂鸣器电路

            上图103.1.2  LED电路


            上图103.1.3  3*3矩阵按键的电路

   “无序”是指两个组合按键不分先后顺序，都能构成组合触发。比如，要触发组合键（S1+S2），先按S1再按S2，或者先按S2再按S1，功能都是一样的。
   本节程序功能如下：（1）S1每单击一次，P1.4所在的LED要么从“灭”变成“亮”，要么从“亮”变成“灭”，在两种状态之间切换。（2）S2每单击一次，P1.5所在的LED要么从“灭”变成“亮”，要么从“亮”变成“灭”，在两种状态之间切换。（3）如果先按住S1再按S2，或者先按住S2再按S1，都认为构造了“无序”组合键，蜂鸣器发出“嘀”的一声。

#include "REG52.H"
#define KEY_VOICE_TIME 50
#define KEY_SHORT_TIME 20
void T0_time();
void SystemInitial(void) ;
void Delay(unsigned long u32DelayTime) ;
void PeripheralInitial(void) ;
void BeepOpen(void);
void BeepClose(void);
void LedOpen_P1_4(void);
void LedClose_P1_4(void);
void LedOpen_P1_5(void);
void LedClose_P1_5(void);
void VoiceScan(void);
void KeyScan(void);
void SingleKeyTask(void);
void DoubleKeyTask(void);
***it P3_4=P3^4;
***it P1_4=P1^4; //P1.4所在的LED
***it P1_5=P1^5; //P1.5所在的LED
***it ROW_INPUT1=P2^2; //第1行输入口。
***it ROW_INPUT2=P2^1; //第2行输入口。
***it ROW_INPUT3=P2^0; //第3行输入口。
***it COLUMN_OUTPUT1=P2^5; //第1列输出口。
***it COLUMN_OUTPUT2=P2^4; //第2列输出口。
***it COLUMN_OUTPUT3=P2^3; //第3列输出口。
volatile unsigned char vGu8BeepTimerFlag=0;
volatile unsigned int vGu16BeepTimerCnt=0;
unsigned char Gu8LedStatus_P1_4=0; //P1.4所在的LED的状态
unsigned char Gu8LedStatus_P1_5=0; //P1.5所在的LED的状态
volatile unsigned char vGu8SingleKeySec=0;
volatile unsigned char vGu8DoubleKeySec=0;
void main()
{
SystemInitial();
Delay(10000);
PeripheralInitial();
while(1)
{
SingleKeyTask();
DoubleKeyTask();
}
}
/* 注释一：
* 矩阵按键“无序”触发的两个最关键地方：
* （1）如果是S1按键先被按下并且单击触发之后，“马上更新输出列的信号状态”，然后切换到
* “S1后面所在的步骤里”，进入到S1和S2两个按键的轮番循环监控之中，如果发现S1按键率先
* 被松开了，就把步骤切换到开始的第一步，重新开始新一轮的按键扫描。
* （2）如果是S2按键先被按下并且单击触发之后，“马上更新输出列的信号状态”，然后切换到
* “S2后面所在的步骤里”，进入到S1和S2两个按键的轮番循环监控之中，如果发现S2按键率先
* 被松开了，就把步骤切换到开始的第一步，重新开始新一轮的按键扫描。
* （3）上面两个描述中的两种步骤，“S1后面所在的步骤里”和“S2后面所在的步骤里”是分开的，
* 不共用的，这是本节破题的关键。
*/
void KeyScan(void) //此函数放在定时中断里每1ms扫描一次
{
static unsigned char Su8KeyLock=0;
static unsigned int Su16KeyCnt=0;
static unsigned char Su8KeyStep=1;
static unsigned char Su8ColumnRecord=0;
switch(Su8KeyStep)
{
case 1:
if(0==Su8ColumnRecord)
{
COLUMN_OUTPUT1=0;
COLUMN_OUTPUT2=1;
COLUMN_OUTPUT3=1;
}
else if(1==Su8ColumnRecord)
{
COLUMN_OUTPUT1=1;
COLUMN_OUTPUT2=0;
COLUMN_OUTPUT3=1;
}
else
{
COLUMN_OUTPUT1=1;
COLUMN_OUTPUT2=1;
COLUMN_OUTPUT3=0;
}
Su16KeyCnt=0;
Su8KeyStep++;
break;
case 2: //等待列输出稳定，但不是去抖动延时
Su16KeyCnt++;
if(Su16KeyCnt>=2)
{
Su16KeyCnt=0;
Su8KeyStep++;
}
break;
case 3:
if(1==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3)
{
Su8KeyStep=1;
Su8KeyLock=0;
Su16KeyCnt=0;
Su8ColumnRecord++;
if(Su8ColumnRecord>=3)
{
Su8ColumnRecord=0;
}
}
else if(0==Su8KeyLock)
{
if(0==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3)
{
Su16KeyCnt++;
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su8KeyLock=1;
if(0==Su8ColumnRecord)
{
vGu8SingleKeySec=1; //单击任务，触发1号键对应S1键
//“马上更新输出列的信号状态”
COLUMN_OUTPUT1=1;
COLUMN_OUTPUT2=0; //列2也输出0，下一步监控S2，非常关键的代码!
COLUMN_OUTPUT3=1;
Su16KeyCnt=0; //去抖动延时清零，为下一步计时做准备
Su8KeyStep=4; //切换到“S1后面所在的步骤里”，破题的关键!!!
}
else if(1==Su8ColumnRecord)
{
vGu8SingleKeySec=2; //单击任务，触发2号键对应S2键
//“马上更新输出列的信号状态”
COLUMN_OUTPUT1=0; //列1也输出0，下一步监控S1，非常关键的代码!
COLUMN_OUTPUT2=1;
COLUMN_OUTPUT3=1;
Su16KeyCnt=0; //去抖动延时清零，为下一步计时做准备
Su8KeyStep=8; //切换到“S2后面所在的步骤里”，破题的关键!!!
}
else if(2==Su8ColumnRecord)
{
vGu8SingleKeySec=3;
}
}
}
else if(1==ROW_INPUT1&&0==ROW_INPUT2&&1==ROW_INPUT3)
{
Su16KeyCnt++;
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su8KeyLock=1;
if(0==Su8ColumnRecord)
{
vGu8SingleKeySec=4;
}
else if(1==Su8ColumnRecord)
{
vGu8SingleKeySec=5;
}
else if(2==Su8ColumnRecord)
{
vGu8SingleKeySec=6;
}
}
}
else if(1==ROW_INPUT1&&1==ROW_INPUT2&&0==ROW_INPUT3)
{
Su16KeyCnt++;
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su8KeyLock=1;
if(0==Su8ColumnRecord)
{
vGu8SingleKeySec=7;
}
else if(1==Su8ColumnRecord)
{
vGu8SingleKeySec=8;
}
else if(2==Su8ColumnRecord)
{
vGu8SingleKeySec=9;
}
}
}
}
break;
/*--------------“S1后面所在的步骤里”------------------*/
case 4: //等待列输出稳定，但不是去抖动延时
Su16KeyCnt++;
if(Su16KeyCnt>=2)
{
Su16KeyCnt=0;
Su8KeyLock=0; //关键语句！自锁清零，为下一步自锁组合按键做准备
Su8KeyStep++;
}
break;
case 5: //判断S2按键
if(1==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3) //S2按键没有被按下
{
Su8KeyLock=0;
Su16KeyCnt=0;
//“马上更新输出列的信号状态”
COLUMN_OUTPUT1=0; //列1输出0，下一步监控S1，非常关键的代码!
COLUMN_OUTPUT2=1;
COLUMN_OUTPUT3=1;
Su8KeyStep++; //切换到下一个步骤，监控S1是否率先已经松开
}
else if(0==Su8KeyLock)
{
if(0==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3) //S2按键被按下
{
Su16KeyCnt++;
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su8KeyLock=1; //组合按键的自锁
vGu8DoubleKeySec=1; //触发组合按键(S1+S2)
}
}
}
break;
case 6: //等待列输出稳定，但不是去抖动延时
Su16KeyCnt++;
if(Su16KeyCnt>=2)
{
Su16KeyCnt=0;
Su8KeyLock=0; //关键语句！自锁清零，为下一步自锁组合按键做准备
Su8KeyStep++;
}
break;
case 7: //监控S1按键是否率先已经松开
if(1==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3)
{
Su16KeyCnt=0;
Su8KeyLock=0;
Su8KeyStep=1; //如果S1按键已经松开，返回到第一个运行步骤重新开始扫描
Su8ColumnRecord++;
if(Su8ColumnRecord>=3)
{
Su8ColumnRecord=0;
}
}
else
{
//“马上更新输出列的信号状态”
COLUMN_OUTPUT1=1;
COLUMN_OUTPUT2=0; //列2输出0，下一步监控S2，非常关键的代码!
COLUMN_OUTPUT3=1;
Su8KeyStep=4; //如果S1按键没有松开，继续返回判断S2是否已按下
}
break;
/*--------------“S2后面所在的步骤里”------------------*/
case 8: //等待列输出稳定，但不是去抖动延时
Su16KeyCnt++;
if(Su16KeyCnt>=2)
{
Su16KeyCnt=0;
Su8KeyLock=0; //关键语句！自锁清零，为下一步自锁组合按键做准备
Su8KeyStep++;
}
break;
case 9: //判断S1按键
if(1==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3) //S1按键没有被按下
{
Su8KeyLock=0;
Su16KeyCnt=0;
//“马上更新输出列的信号状态”
COLUMN_OUTPUT1=1;
COLUMN_OUTPUT2=0; //列2输出0，下一步监控S2，非常关键的代码!
COLUMN_OUTPUT3=1;
Su8KeyStep++; //切换到下一个步骤，监控S2是否率先已经松开
}
else if(0==Su8KeyLock)
{
if(0==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3) //S1按键被按下
{
Su16KeyCnt++;
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su8KeyLock=1; //组合按键的自锁
vGu8DoubleKeySec=1; //触发组合按键(S1+S2)
}
}
}
break;
case 10: //等待列输出稳定，但不是去抖动延时
Su16KeyCnt++;
if(Su16KeyCnt>=2)
{
Su16KeyCnt=0;
Su8KeyLock=0; //关键语句！自锁清零，为下一步自锁组合按键做准备
Su8KeyStep++;
}
break;
case 11: //监控S2按键是否率先已经松开
if(1==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3)
{
Su16KeyCnt=0;
Su8KeyLock=0;
Su8KeyStep=1; //如果S2按键已经松开，返回到第一个运行步骤重新开始扫描
Su8ColumnRecord++;
if(Su8ColumnRecord>=3)
{
Su8ColumnRecord=0;
}
}
else
{
//“马上更新输出列的信号状态”
COLUMN_OUTPUT1=0; //列1输出0，下一步监控S1，非常关键的代码!
COLUMN_OUTPUT2=1;
COLUMN_OUTPUT3=1;
Su8KeyStep=8; //如果S2按键没有松开，继续返回判断S1是否已按下
}
break;
}
}
void SingleKeyTask(void)
{
if(0==vGu8SingleKeySec)
{
return;
}
switch(vGu8SingleKeySec)
{
case 1: //S1按键的单击任务，更改P1.4所在的LED灯的显示状态
if(0==Gu8LedStatus_P1_4)
{
Gu8LedStatus_P1_4=1;
LedOpen_P1_4();
}
else
{
Gu8LedStatus_P1_4=0;
LedClose_P1_4();
}
vGu8SingleKeySec=0;
break;
case 2: //S2按键的单击任务，更改P1.5所在的LED灯的显示状态
if(0==Gu8LedStatus_P1_5)
{
Gu8LedStatus_P1_5=1;
LedOpen_P1_5();
}
else
{
Gu8LedStatus_P1_5=0;
LedClose_P1_5();
}
vGu8SingleKeySec=0;
break;
default:
vGu8SingleKeySec=0;
break;
}
}
void DoubleKeyTask(void)
{
if(0==vGu8DoubleKeySec)
{
return;
}
switch(vGu8DoubleKeySec)
{
case 1: //S1与S2的组合按键触发，发出“嘀”一声
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME;
vGu8BeepTimerFlag=1;
vGu8DoubleKeySec=0;
break;
}
}
void T0_time() interrupt 1
{
VoiceScan();
KeyScan();
TH0=0xfc;
TL0=0x66;
}
void SystemInitial(void)
{
TMOD=0x01;
TH0=0xfc;
TL0=0x66;
EA=1;
ET0=1;
TR0=1;
}
void Delay(unsigned long u32DelayTime)
{
for(;u32DelayTime>0;u32DelayTime--);
}
void PeripheralInitial(void)
{
if(0==Gu8LedStatus_P1_4)
{
LedClose_P1_4();
}
else
{
LedOpen_P1_4();
}
if(0==Gu8LedStatus_P1_5)
{
LedClose_P1_5();
}
else
{
LedOpen_P1_5();
}
}
void BeepOpen(void)
{
P3_4=0;
}
void BeepClose(void)
{
P3_4=1;
}
void LedOpen_P1_4(void)
{
P1_4=0;
}
void LedClose_P1_4(void)
{
P1_4=1;
}
void LedOpen_P1_5(void)
{
P1_5=0;
}
void LedClose_P1_5(void)
{
P1_5=1;
}
void VoiceScan(void)
{
static unsigned char Su8Lock=0;
if(1==vGu8BeepTimerFlag&&vGu16BeepTimerCnt>0)
{
if(0==Su8Lock)
{
Su8Lock=1;
BeepOpen();
}
else
{
vGu16BeepTimerCnt--;
if(0==vGu16BeepTimerCnt)
{
Su8Lock=0;
BeepClose();
}
}
}
}

复制代码

ZHAOLH · 2018-1-15 10:08:06

每周必来！！！！！！

凯胜低温制冷 · 2018-1-16 22:16:24

非常好,谢谢分享

吴坚鸿 · 2018-1-22 15:17:18

第一百零四节：矩阵按键“一键两用”的短按与长按。

【104.1 “一键两用”的短按与长按。】


            上图104.1.1  有源蜂鸣器电路


            上图104.1.2  LED电路


            上图104.1.3  3*3矩阵按键的电路

      矩阵按键与前面章节独立按键的“短按与长按”的处理思路是一样的，本节讲矩阵按键的“短按与长按”，也算是重温之前章节讲的内容。“短按与长按”的原理是依赖“按键按下的时间长度”来区分识别。“短按”是指从按下的“下降沿”到松手的“上升沿”时间，“长按”是指从按下的“下降沿”到一直按住不松手的“低电平持续时间”。本节的例程功能如下：（1）S1每“短按”一次，LED要么从“灭”变成“亮”，要么从“亮”变成“灭”，在两种状态之间切换。（2）S1每“长按”一次，蜂鸣器发出“嘀”的一声。代码如下：

#include "REG52.H"
#define KEY_VOICE_TIME 50
#define KEY_SHORT_TIME 20 //按键的“短按”兼“滤波”的“稳定时间”
#define KEY_LONG_TIME 400 //按键的“长按”兼“滤波”的“稳定时间”
void T0_time();
void SystemInitial(void) ;
void Delay(unsigned long u32DelayTime) ;
void PeripheralInitial(void) ;
void BeepOpen(void);
void BeepClose(void);
void LedOpen_P1_4(void);
void LedClose_P1_4(void);
void VoiceScan(void);
void KeyScan(void);
void KeyTask(void);
***it P3_4=P3^4;
***it P1_4=P1^4;
***it ROW_INPUT1=P2^2; //第1行输入口。
***it ROW_INPUT2=P2^1; //第2行输入口。
***it ROW_INPUT3=P2^0; //第3行输入口。
***it COLUMN_OUTPUT1=P2^5; //第1列输出口。
***it COLUMN_OUTPUT2=P2^4; //第2列输出口。
***it COLUMN_OUTPUT3=P2^3; //第3列输出口。
volatile unsigned char vGu8BeepTimerFlag=0;
volatile unsigned int vGu16BeepTimerCnt=0;
unsigned char Gu8LedStatus_P1_4=0;
volatile unsigned char vGu8KeySec=0; //短按与长按共用一个全局变量vGu8KeySec来传递按键信息
void main()
{
SystemInitial();
Delay(10000);
PeripheralInitial();
while(1)
{
KeyTask();
}
}
/* 注释一：
* 本节破题的关键：
* 矩阵按键涉及的按键数量很多，但是实际项目上一般只需要少数个别按键具备这种
* “短按”与“长按”的特殊技能，因此，在代码上，必须把这类“特殊技能按键”与
* “大众按键”区分开来，才能相互清晰互不干扰。本节的“特殊技能按键”是S1。
*/
void KeyScan(void) //此函数放在定时中断里每1ms扫描一次
{
static unsigned char Su8KeyLock=0;
static unsigned int Su16KeyCnt=0;
static unsigned char Su8KeyStep=1;
static unsigned char Su8ColumnRecord=0;
static unsigned char Su8KeyShortFlag_S1=0; //S1按键专属的“短按”触发标志
switch(Su8KeyStep)
{
case 1:
if(0==Su8ColumnRecord)
{
COLUMN_OUTPUT1=0;
COLUMN_OUTPUT2=1;
COLUMN_OUTPUT3=1;
}
else if(1==Su8ColumnRecord)
{
COLUMN_OUTPUT1=1;
COLUMN_OUTPUT2=0;
COLUMN_OUTPUT3=1;
}
else
{
COLUMN_OUTPUT1=1;
COLUMN_OUTPUT2=1;
COLUMN_OUTPUT3=0;
}
Su16KeyCnt=0;
Su8KeyStep++;
break;
case 2: //等待列输出稳定，但不是去抖动延时
Su16KeyCnt++;
if(Su16KeyCnt>=2)
{
Su16KeyCnt=0;
Su8KeyStep++;
}
break;
case 3:
if(1==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3)
{
Su8KeyStep=1;
Su8KeyLock=0;
Su16KeyCnt=0;
if(1==Su8KeyShortFlag_S1) //松手的时候，如果“短按”标志有效就触发一次“短按”
{
Su8KeyShortFlag_S1=0; //先清零“短按”标志避免一直触发。
vGu8KeySec=1; //触发S1的“短按”
}
Su8ColumnRecord++;
if(Su8ColumnRecord>=3)
{
Su8ColumnRecord=0;
}
}
else if(0==Su8KeyLock)
{
//以下第1行，直接把S1按键单独扣出来，用“&&0==Su8ColumnRecord”作为筛选条件
if(0==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3&&0==Su8ColumnRecord)
{
Su16KeyCnt++;
if(Su16KeyCnt>=KEY_SHORT_TIME) //“短按”兼“滤波”的“稳定时间”
{
//注意，这里不能“自锁”。后面“长按”触发的时候才“自锁”。
Su8KeyShortFlag_S1=1; //S1的“短按”标志有效，待松手时触发。
}
if(Su16KeyCnt>=KEY_LONG_TIME) //“长按”兼“滤波”的“稳定时间”
{
Su8KeyLock=1; //此时“长按”触发才“自锁”
Su8KeyShortFlag_S1=0; //既然此时“长按”有效，那么就要废除潜在的“短按”。
vGu8KeySec=21; //触发S1的“长按”
}
}
else if(0==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3)
{
Su16KeyCnt++;
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su8KeyLock=1;
//既然S1按键已经被上面几行代码单独扣出来，这里就直接从S2按键开始判断
if(1==Su8ColumnRecord)
{
vGu8KeySec=2;
}
else if(2==Su8ColumnRecord)
{
vGu8KeySec=3;
}
}
}
else if(1==ROW_INPUT1&&0==ROW_INPUT2&&1==ROW_INPUT3)
{
Su16KeyCnt++;
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su8KeyLock=1;
if(0==Su8ColumnRecord)
{
vGu8KeySec=4;
}
else if(1==Su8ColumnRecord)
{
vGu8KeySec=5;
}
else if(2==Su8ColumnRecord)
{
vGu8KeySec=6;
}
}
}
else if(1==ROW_INPUT1&&1==ROW_INPUT2&&0==ROW_INPUT3)
{
Su16KeyCnt++;
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su8KeyLock=1;
if(0==Su8ColumnRecord)
{
vGu8KeySec=7;
}
else if(1==Su8ColumnRecord)
{
vGu8KeySec=8;
}
else if(2==Su8ColumnRecord)
{
vGu8KeySec=9;
}
}
}
}
break;
}
}
void KeyTask(void)
{
if(0==vGu8KeySec)
{
return;
}
switch(vGu8KeySec)
{
case 1: //S1按键的“短按”任务，更改P1.4所在的LED灯的显示状态
if(0==Gu8LedStatus_P1_4)
{
Gu8LedStatus_P1_4=1;
LedOpen_P1_4();
}
else
{
Gu8LedStatus_P1_4=0;
LedClose_P1_4();
}
vGu8KeySec=0;
break;
//以下S1按键的“长按”直接选择case 21的“21”，是为了不占用前排其它按键的编号。
case 21: //S1按键的“长按”任务，蜂鸣器发出“嘀”一声
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //蜂鸣器发出“嘀”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0;
break;
default:
vGu8KeySec=0;
break;
}
}
void T0_time() interrupt 1
{
VoiceScan();
KeyScan();
TH0=0xfc;
TL0=0x66;
}
void SystemInitial(void)
{
TMOD=0x01;
TH0=0xfc;
TL0=0x66;
EA=1;
ET0=1;
TR0=1;
}
void Delay(unsigned long u32DelayTime)
{
for(;u32DelayTime>0;u32DelayTime--);
}
void PeripheralInitial(void)
{
if(0==Gu8LedStatus_P1_4)
{
LedClose_P1_4();
}
else
{
LedOpen_P1_4();
}
}
void BeepOpen(void)
{
P3_4=0;
}
void BeepClose(void)
{
P3_4=1;
}
void LedOpen_P1_4(void)
{
P1_4=0;
}
void LedClose_P1_4(void)
{
P1_4=1;
}
void VoiceScan(void)
{
static unsigned char Su8Lock=0;
if(1==vGu8BeepTimerFlag&&vGu16BeepTimerCnt>0)
{
if(0==Su8Lock)
{
Su8Lock=1;
BeepOpen();
}
else
{
vGu16BeepTimerCnt--;
if(0==vGu16BeepTimerCnt)
{
Su8Lock=0;
BeepClose();
}
}
}
}

复制代码

吴坚鸿 · 2018-1-28 12:52:32

第一百零五节：矩阵按键按住不松手的连续均匀触发。

【105.1 按住不松手的连续均匀触发。】


            上图105.1.1  有源蜂鸣器电路


            上图105.1.2  LED电路


            上图105.1.3  3*3矩阵按键的电路

   矩阵按键与前面章节独立按键的“按住不松手的连续均匀触发”的处理思路是一样的。在电脑上删除某个文件某行文字的时候，单击一次“退格按键[Backspace]”，就删除一个文字，如果按住“退格按键[Backspace]”不松手，就会“连续均匀”的触发“删除”的功能，自动逐个把整行文字删除清空，这就是“按住不松手的连续均匀触发”应用案例之一。除此之外，在很多需要人机交互的项目中都有这样的功能，为了快速加减某个数值，按住某个按键不松手，某个数值有节奏地快速往上加或者快速往下减。这种“按住不松手连续均匀触发”的按键识别，在程序上有“3个时间”需要留意，第1个是按键单击的“滤波”时间，第2个是按键“从单击进入连击”的间隔时间（此时间是“单击”与“连击”的分界线），第3个是按键“连击”的间隔时间，
   本节例程实现的功能如下：（1）8个受按键控制的跑马灯在某一时刻只有1个LED亮，每触发一次S1按键，“亮的LED”就“往左边跑一步”；相反，每触发一次S9按键，“亮的LED”就“往右边跑一步”。如果按住S1或者S9不松手就连续触发，“亮的LED”就“连续跑”，一直跑到左边或者右边的尽头。（2）按键每“单击”一次S1或者S9蜂鸣器就鸣叫一次，但是，当按键“从单击进入连击”后，蜂鸣器就不鸣叫。代码如下：

#include "REG52.H"
#define KEY_VOICE_TIME 50
#define KEY_SHORT_TIME 20 //按键单击的“滤波”时间
#define KEY_ENTER_CONTINUITY_TIME 240 //按键“从单击进入连击”的间隔时间
#define KEY_CONTINUITY_TIME 64 //按键“连击”的间隔时间
#define BUS_P0 P0 //8个LED灯一一对应单片机的P0口总线
void T0_time();
void SystemInitial(void) ;
void Delay(unsigned long u32DelayTime) ;
void PeripheralInitial(void) ;
void BeepOpen(void);
void BeepClose(void);
void VoiceScan(void);
void KeyScan(void);
void KeyTask(void);
void DisplayTask(void); //显示的任务函数（LED显示状态）
***it P3_4=P3^4;
***it ROW_INPUT1=P2^2; //第1行输入口。
***it ROW_INPUT2=P2^1; //第2行输入口。
***it ROW_INPUT3=P2^0; //第3行输入口。
***it COLUMN_OUTPUT1=P2^5; //第1列输出口。
***it COLUMN_OUTPUT2=P2^4; //第2列输出口。
***it COLUMN_OUTPUT3=P2^3; //第3列输出口。
volatile unsigned char vGu8BeepTimerFlag=0;
volatile unsigned int vGu16BeepTimerCnt=0;
unsigned char Gu8LedStatus=0; //LED灯的状态
unsigned char Gu8DisplayUpdate=1; //显示的刷新标志
volatile unsigned char vGu8KeySec=0; //按键的触发序号
volatile unsigned char vGu8ShieldVoiceFlag=0; //屏蔽声音的标志
void main()
{
SystemInitial();
Delay(10000);
PeripheralInitial();
while(1)
{
KeyTask();
DisplayTask(); //显示的任务函数（LED显示状态）
}
}
/* 注释一：
* Gu8DisplayUpdate这类“显示刷新变量”在“显示框架”里是很常见的，而且屡用屡爽。
* 目的是，既能及时刷新显示，又能避免主函数“不断去执行显示代码”而影响程序效率。
*/
void DisplayTask(void) //显示的任务函数（LED显示状态）
{
if(1==Gu8DisplayUpdate) //需要刷新一次显示
{
Gu8DisplayUpdate=0; //及时清零，避免主函数“不断去执行显示代码”而影响程序效率
//Gu8LedStatus是左移的位数，范围（0至7），决定了跑马灯的显示状态。
BUS_P0=~(1<
}
}
/* 注释二：
* 本节破题的关键：
* 矩阵按键涉及的按键数量很多，但是实际项目上一般只需要少数个别按键具备这种
* “单击”与“连续均匀触发”的特殊技能，因此，在代码上，必须把这类“特殊技能按键”与
* “大众按键”区分开来，才能相互清晰互不干扰。本节的“特殊技能按键”是S1和S9。
* 如果觉得本节的讲解不够详细具体，请先阅读一下前面章节“独立按键按住不松手的连续均匀触发”。
*/
void KeyScan(void) //此函数放在定时中断里每1ms扫描一次
{
static unsigned char Su8KeyLock=0;
static unsigned int Su16KeyCnt=0;
static unsigned char Su8KeyStep=1;
static unsigned char Su8ColumnRecord=0;
switch(Su8KeyStep)
{
case 1:
if(0==Su8ColumnRecord)
{
COLUMN_OUTPUT1=0;
COLUMN_OUTPUT2=1;
COLUMN_OUTPUT3=1;
}
else if(1==Su8ColumnRecord)
{
COLUMN_OUTPUT1=1;
COLUMN_OUTPUT2=0;
COLUMN_OUTPUT3=1;
}
else
{
COLUMN_OUTPUT1=1;
COLUMN_OUTPUT2=1;
COLUMN_OUTPUT3=0;
}
Su16KeyCnt=0;
Su8KeyStep++;
break;
case 2: //等待列输出稳定，但不是去抖动延时
Su16KeyCnt++;
if(Su16KeyCnt>=2)
{
Su16KeyCnt=0;
Su8KeyStep++;
}
break;
case 3:
if(1==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3)
{
Su8KeyStep=1; //返回步骤1继续扫描
Su8KeyLock=0;
Su16KeyCnt=0;
Su8ColumnRecord++;
if(Su8ColumnRecord>=3)
{
Su8ColumnRecord=0;
}
}
else if(0==Su8KeyLock)
{
if(0==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3)
{
Su16KeyCnt++;
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su8KeyLock=1;
if(0==Su8ColumnRecord)
{
vGu8KeySec=1; //触发一次单击
Su16KeyCnt=0; //计时器清零，为即将来临的计时做准备
Su8KeyStep=4; //跳到S1按键的专属区，脱离大众按键
}
else if(1==Su8ColumnRecord)
{
vGu8KeySec=2;
}
else if(2==Su8ColumnRecord)
{
vGu8KeySec=3;
}
}
}
else if(1==ROW_INPUT1&&0==ROW_INPUT2&&1==ROW_INPUT3)
{
Su16KeyCnt++;
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su8KeyLock=1;
if(0==Su8ColumnRecord)
{
vGu8KeySec=4;
}
else if(1==Su8ColumnRecord)
{
vGu8KeySec=5;
}
else if(2==Su8ColumnRecord)
{
vGu8KeySec=6;
}
}
}
else if(1==ROW_INPUT1&&1==ROW_INPUT2&&0==ROW_INPUT3)
{
Su16KeyCnt++;
if(Su16KeyCnt>=KEY_SHORT_TIME)
{
Su8KeyLock=1;
if(0==Su8ColumnRecord)
{
vGu8KeySec=7;
}
else if(1==Su8ColumnRecord)
{
vGu8KeySec=8;
}
else if(2==Su8ColumnRecord)
{
vGu8KeySec=9; //触发一次单击
Su16KeyCnt=0; //计时器清零，为即将来临的计时做准备
Su8KeyStep=6; //跳到S9按键的专属区，脱离大众按键
}
}
}
}
break;
/*---------S1按键的专属区----------------*/
case 4:
if(0==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3) //仅判断S1按键，避免交叉影响
{
Su16KeyCnt++;
if(Su16KeyCnt>=KEY_ENTER_CONTINUITY_TIME)//该时间是“单击”与“连击”的分界线
{
Su16KeyCnt=0; //计时器清零，为即将来临的计时做准备
Su8KeyStep=5; //S1按键进入有节奏的连续触发
}
}
else //如果期间检查到S1按键已经松手
{
Su8KeyStep=1; //返回步骤1继续扫描
Su8KeyLock=0;
Su16KeyCnt=0;
Su8ColumnRecord++;
if(Su8ColumnRecord>=3)
{
Su8ColumnRecord=0;
}
}
break;
case 5: //S1按键进入有节奏的连续触发
if(0==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3) //仅判断S1按键，避免交叉影响
{
Su16KeyCnt++;
if(Su16KeyCnt>=KEY_CONTINUITY_TIME) //该时间是“连击”的时间
{
Su16KeyCnt=0; //清零，为了继续连击。
vGu8KeySec=1; //触发一次S1按键
vGu8ShieldVoiceFlag=1; //因为连击，把当前按键触发的声音屏蔽掉
}
}
else //如果期间检查到S1按键已经松手
{
Su8KeyStep=1; //返回步骤1继续扫描
Su8KeyLock=0;
Su16KeyCnt=0;
Su8ColumnRecord++;
if(Su8ColumnRecord>=3)
{
Su8ColumnRecord=0;
}
}
break;
/*---------S9按键的专属区----------------*/
case 6:
if(1==ROW_INPUT1&&1==ROW_INPUT2&&0==ROW_INPUT3) //仅判断S9按键，避免交叉影响
{
Su16KeyCnt++;
if(Su16KeyCnt>=KEY_ENTER_CONTINUITY_TIME)//该时间是“单击”与“连击”的分界线
{
Su16KeyCnt=0; //计时器清零，为即将来临的计时做准备
Su8KeyStep=7; //S9按键进入有节奏的连续触发
}
}
else //如果期间检查到S9按键已经松手
{
Su8KeyStep=1; //返回步骤1继续扫描
Su8KeyLock=0;
Su16KeyCnt=0;
Su8ColumnRecord++;
if(Su8ColumnRecord>=3)
{
Su8ColumnRecord=0;
}
}
break;
case 7: //S9按键进入有节奏的连续触发
if(1==ROW_INPUT1&&1==ROW_INPUT2&&0==ROW_INPUT3) //仅判断S9按键，避免交叉影响
{
Su16KeyCnt++;
if(Su16KeyCnt>=KEY_CONTINUITY_TIME) //该时间是“连击”的时间
{
Su16KeyCnt=0; //清零，为了继续连击。
vGu8KeySec=9; //触发一次S9按键
vGu8ShieldVoiceFlag=1; //因为连击，把当前按键触发的声音屏蔽掉
}
}
else //如果期间检查到S9按键已经松手
{
Su8KeyStep=1; //返回步骤1继续扫描
Su8KeyLock=0;
Su16KeyCnt=0;
Su8ColumnRecord++;
if(Su8ColumnRecord>=3)
{
Su8ColumnRecord=0;
}
}
break;
}
}
void KeyTask(void)
{
if(0==vGu8KeySec)
{
return;
}
switch(vGu8KeySec)
{
case 1: //S1按键的任务
if(Gu8LedStatus>0)
{
Gu8LedStatus--; //控制LED“往左边跑”
Gu8DisplayUpdate=1; //刷新显示
}
if(0==vGu8ShieldVoiceFlag) //声音没有被屏蔽
{
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //发出“嘀”一声
vGu8BeepTimerFlag=1;
}
vGu8ShieldVoiceFlag=0; //及时把屏蔽标志清零，避免平时正常的单击声音也被淹没。
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一致触发
break;
case 9: //S9按键的任务
if(Gu8LedStatus<7)
{
Gu8LedStatus++; //控制LED“往右边跑”
Gu8DisplayUpdate=1; //刷新显示
}
if(0==vGu8ShieldVoiceFlag) //声音没有被屏蔽
{
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //发出“嘀”一声
vGu8BeepTimerFlag=1;
}
vGu8ShieldVoiceFlag=0; //及时把屏蔽标志清零，避免平时正常的单击声音也被淹没。
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一致触发
break;
default:
vGu8KeySec=0;
break;
}
}
void T0_time() interrupt 1
{
VoiceScan();
KeyScan();
TH0=0xfc;
TL0=0x66;
}
void SystemInitial(void)
{
TMOD=0x01;
TH0=0xfc;
TL0=0x66;
EA=1;
ET0=1;
TR0=1;
}
void Delay(unsigned long u32DelayTime)
{
for(;u32DelayTime>0;u32DelayTime--);
}
void PeripheralInitial(void)
{
}
void BeepOpen(void)
{
P3_4=0;
}
void BeepClose(void)
{
P3_4=1;
}
void VoiceScan(void)
{
static unsigned char Su8Lock=0;
if(1==vGu8BeepTimerFlag&&vGu16BeepTimerCnt>0)
{
if(0==Su8Lock)
{
Su8Lock=1;
BeepOpen();
}
else
{
vGu16BeepTimerCnt--;
if(0==vGu16BeepTimerCnt)
{
Su8Lock=0;
BeepClose();
}
}
}
}

复制代码

吴坚鸿 · 2018-2-4 12:19:23

第一百零六节：矩阵按键按住不松手的“先加速后匀速”触发。

【106.1 按住不松手的先加速后匀速触发。】


            上图106.1.1  有源蜂鸣器电路


            上图106.1.2  LED电路


            上图106.1.3  3*3矩阵按键的电路

      矩阵按键与前面章节“独立按键按住不松手的先加速后匀速的触发”的处理思路是一样的。当“连续加”或者“连续减”的数据范围很大的时候，就需要按键的加速与匀速相结合的触发方式。“加速”是指按住按键不松手，按键刚开始触发是从慢到快的渐进过程，当“加速”到某个特别快的速度的时候，就“不再加速”，而是以该“恒定高速”进行“连续匀速”触发。这种触发方式，“加速”和“匀速”是相辅相成缺一不可的，为什么？假如没有“加速”只有“匀速”，那么刚按下按键就直接以最高速的“匀速”进行，就会跑过头，缺乏微调功能；而假如没有“匀速”只有“加速”，那么按下按键不松手后，速度就会一直不断飙升，最后失控过冲。
   本节例程实现的功能如下：
   （1）要更改一个“设置参数”（一个全局变量），参数的范围是0到800。
   （2）8个受“设置参数”控制的跑马灯在某一时刻只有1个LED亮，每触发一次S1按键，该“设置参数”就自减1，最小值为0；相反，每触发一次S9按键，该“设置参数”就自加1，最大值为800。
   （3）LED灯实时显示“设置参数”的范围状态：
            只有第0个LED灯亮：0<=“设置参数”<100。
            只有第1个LED灯亮：100<=“设置参数”<200。
            只有第2个LED灯亮：200<=“设置参数”<300。
            只有第3个LED灯亮：300<=“设置参数”<400。
            只有第4个LED灯亮：400<=“设置参数”<500。
            只有第5个LED灯亮：500<=“设置参数”<600。
            只有第6个LED灯亮：600<=“设置参数”<700。
            只有第7个LED灯亮：700<=“设置参数”<=800。
   （4）按键每“单击”一次蜂鸣器就鸣叫一次，但是，当按键“从单击进入连击”后，蜂鸣器就不鸣叫。