21ic电子技术开发论坛 › 单片机与嵌入式系统 › 侃单片机论坛 › 从单片机基础到程序框架（连载）
1 ...131415161718192021... 34下一页
返回列表 发新帖我要提问本帖赏金: 82.00元(功能说明)

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

[复制链接]
362971|721
 楼主| jianhong_wu 发表于 2017-10-29 10:57 | 显示全部楼层
本帖最后由 jianhong_wu 于 2017-10-29 11:49 编辑

第九十三节： 独立按键鼠标式的单击与双击。

【93.1   鼠标式的单击与双击。】




                上图93.1.1  独立按键电路


     
                上图93.1.2  LED电路

              
                上图93.1.3  有源蜂鸣器电路

        鼠标的左键，可以触发单击，也可以触发双击。双击的规则是这样的，两次单击，如果第1次单击与第2次单击的时间比较“短”的时候，则这两次单击就构成双击。编写这个程序的最大亮点是如何控制好第1次单击与第2次单击的时间间隔。程序例程要实现的功能是：（1）单击改变LED灯的显示状态，单击一次LED从原来“灭”的状态变成“亮”的状态，或者从原来“亮”的状态变成“灭”的状态，依次循环切换。（2）双击则蜂鸣器发出“嘀”的一声。代码如下：
复制
  1. #include "REG52.H"  
    


  2. 

  3. #define KEY_VOICE_TIME   50     //按键触发后发出的声音长度  
    

  4. #define KEY_FILTER_TIME  25     //按键滤波的“稳定时间”25ms
    

  5. #define KEY_INTERVAL_TIME  250  //连续两次单击之间的最大有效时间250ms
    


  6. 

  7. void T0_time();
    

  8. void SystemInitial(void) ;
    

  9. void Delay(unsigned long u32DelayTime) ;
    

  10. void PeripheralInitial(void) ;
    


  11. 

  12. void BeepOpen(void);   
    

  13. void BeepClose(void); 
    

  14. void LedOpen(void);   
    

  15. void LedClose(void); 
    


  16. 

  17. void VoiceScan(void);
    

  18. void KeyScan(void);    //按键识别的驱动函数，放在定时中断里
    

  19. void SingleKeyTask(void);   //单击按键任务函数，放在主函数内
    

  20. void DoubleKeyTask(void);   //双击按键任务函数，放在主函数内
    


  21. 

  22. sbit P3_4=P3^4;       //蜂鸣器
    

  23. sbit P1_4=P1^4;       //LED
    


  24. 

  25. sbit KEY_INPUT1=P2^2;  //K1按键识别的输入口。
    


  26. 

  27. volatile unsigned char vGu8BeepTimerFlag=0;  
    

  28. volatile unsigned int vGu16BeepTimerCnt=0;  
    


  29. 

  30. unsigned char Gu8LedStatus=0; //记录LED灯的状态，0代表灭，1代表亮
    

  31. volatile unsigned char vGu8SingleKeySec=0;  //单击按键的触发序号
    

  32. volatile unsigned char vGu8DoubleKeySec=0;  //双击按键的触发序号
    


  33. 

  34. void main() 
    

  35. {
    

  36. SystemInitial();            
    

  37. Delay(10000);               
    

  38. PeripheralInitial();      
    

  39.     while(1)  
    

  40. {  
    

  41.    SingleKeyTask();    //单击按键任务函数
    

  42.    DoubleKeyTask();    //双击按键任务函数
    

  43.     }
    

  44. }
    


  45. 

  46. void T0_time() interrupt 1     
    

  47. {
    

  48. VoiceScan();  
    

  49. KeyScan();    //按键识别的驱动函数
    


  50. 

  51. TH0=0xfc;   
    

  52. TL0=0x66;   
    

  53. }
    


  54. 


  55. 

  56. void SystemInitial(void) 
    

  57. {
    

  58. TMOD=0x01;  
    

  59. TH0=0xfc;   
    

  60. TL0=0x66;   
    

  61. EA=1;       
    

  62. ET0=1;      
    

  63. TR0=1;      
    

  64. }
    


  65. 

  66. void Delay(unsigned long u32DelayTime) 
    

  67. {
    

  68.     for(;u32DelayTime>0;u32DelayTime--); 
    

  69. }
    


  70. 

  71. void PeripheralInitial(void) 
    

  72. {
    

  73. /* 注释一：
    

  74. * 把LED的初始化放在PeripheralInitial而不是放在SystemInitial，是因为LED显示内容对上电
    

  75. * 瞬间的要求不高。但是，如果是控制继电器，则应该把继电器的输出初始化放在SystemInitial。
    

  76. */
    


  77. 

  78.     //根据Gu8LedStatus的值来初始化LED当前的显示状态，0代表灭，1代表亮
    

  79. if(0==Gu8LedStatus) 
    

  80. {
    

  81.     LedClose();  //关闭LED
    

  82. }
    

  83. else 
    

  84. {
    

  85.     LedOpen();   //点亮LED
    

  86. }
    

  87. }
    


  88. 

  89. void BeepOpen(void)
    

  90. {
    

  91. P3_4=0;  
    

  92. }
    


  93. 

  94. void BeepClose(void)
    

  95. {
    

  96. P3_4=1;  
    

  97. }
    

  98. void LedOpen(void)
    

  99. {
    

  100. P1_4=0;  
    

  101. }
    


  102. 

  103. void LedClose(void)
    

  104. {
    

  105. P1_4=1;  
    

  106. }
    


  107. 

  108. void VoiceScan(void)
    

  109. {
    


  110. 

  111.           static unsigned char Su8Lock=0;  
    


  112. 

  113. if(1==vGu8BeepTimerFlag&&vGu16BeepTimerCnt>0)
    

  114.           {
    

  115.                   if(0==Su8Lock)
    

  116.                   {
    

  117.                    Su8Lock=1;  
    

  118. BeepOpen(); 
    

  119.      }
    

  120.     else  
    

  121. {     
    


  122. 

  123.                        vGu16BeepTimerCnt--;         
    


  124. 

  125.                    if(0==vGu16BeepTimerCnt)
    

  126.                    {
    

  127.                            Su8Lock=0;     
    

  128. BeepClose();  
    

  129.                    }
    


  130. 

  131. }
    

  132.           }         
    

  133. }
    


  134. 

  135. /* 注释二：
    

  136. * 双击按键扫描的详细过程：
    

  137. * 第一步：平时没有按键被触发时，按键的自锁标志,去抖动延时计数器一直被清零。
    

  138. *         如果之前已经有按键触发过1次单击，那么启动时间间隔计数器Su16KeyIntervalCnt1，
    

  139. *         在KEY_INTERVAL_TIME这个允许的时间差范围内，如果一直没有第2次单击触发，
    

  140. *         则把累加按键触发的次数Su8KeyTouchCnt1也清零，上一次累计的单击数被清零，
    

  141. *         就意味着下一次新的双击必须重新开始累加两次单击数。
    

  142. * 第二步：一旦有按键被按下，去抖动延时计数器开始在定时中断函数里累加，在还没累加到
    

  143. *         阀值KEY_FILTER_TIME时，如果在这期间由于受外界干扰或者按键抖动，而使
    

  144. *         IO口突然瞬间触发成高电平，这个时候马上把延时计数器Su16KeyTimeCnt1
    

  145. *         清零了,这个过程非常巧妙，非常有效地去除瞬间的杂波干扰，以后凡是用到开关感应器的时候，
    

  146. *         都可以用类似这样的方法去干扰。
    

  147. * 第三步：如果按键按下的时间超过了阀值KEY_FILTER_TIME，马上把自锁标志Su8KeyLock1置1，
    

  148. *         防止按住按键不松手后一直触发。与此同时，累加1次按键次数，如果按键次数累加有2次，
    

  149. *         则认为触发双击按键，并把编号vGu8DoubleKeySec赋值。 
    

  150. * 第四步：等按键松开后，自锁标志Su8KeyLock1及时清零解锁，为下一次自锁做准备。并且累加间隔时间，
    

  151. *         防止两次按键的间隔时间太长。如果连续2次单击的间隔时间太长达到了KEY_INTERVAL_TIME
    

  152. *         的长度，立即清零当前按键次数的计数器，这样意味着上一次的累加单击数无效，下一次双击
    

  153. *         必须重新累加新的单击数。
    

  154. */
    


  155. 

  156. void KeyScan(void)  //此函数放在定时中断里每1ms扫描一次
    

  157. {
    

  158.    static unsigned char Su8KeyLock1;           //1号按键的自锁
    

  159.    static unsigned int  Su16KeyCnt1;           //1号按键的计时器
    

  160.    static unsigned char Su8KeyTouchCnt1;       //1号按键的次数记录
    

  161.    static unsigned int  Su16KeyIntervalCnt1;   //1号按键的间隔时间计数器
    

  162.  
    

  163.    //1号按键
    

  164.    if(0!=KEY_INPUT1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
    

  165.    {
    

  166.        Su8KeyLock1=0; //按键解锁
    

  167.        Su16KeyCnt1=0; //按键去抖动延时计数器清零，此行非常巧妙。      
    

  168.        if(Su8KeyTouchCnt1>=1) //之前已经有按键触发过一次，再来一次就构成双击
    

  169.        {
    

  170.            Su16KeyIntervalCnt1++; //按键间隔的时间计数器累加
    

  171.            if(Su16KeyIntervalCnt1>=KEY_INTERVAL_TIME) //达到最大允许的间隔时间
    

  172.            {
    

  173.                Su16KeyIntervalCnt1=0; //时间计数器清零
    

  174.                Su8KeyTouchCnt1=0;     //清零按键的按下的次数
    

  175.            }
    

  176.        }
    

  177.    }
    

  178.    else if(0==Su8KeyLock1)//有按键按下，且是第一次被按下。此行如有疑问，请看第92节的讲解。
    

  179.    {
    

  180.       Su16KeyCnt1++; //累加定时中断次数
    

  181.       if(Su16KeyCnt1>=KEY_FILTER_TIME) //滤波的“稳定时间”KEY_FILTER_TIME，长度是25ms。
    

  182.       {
    

  183.          Su8KeyLock1=1;  //按键的自锁,避免一直触发
    

  184.          Su16KeyIntervalCnt1=0;   //按键有效间隔的时间计数器清零
    

  185.          Su8KeyTouchCnt1++;       //记录当前单击的次数
    

  186.          if(1==Su8KeyTouchCnt1)   //只按了1次
    

  187.          {
    

  188.               vGu8SingleKeySec=1;     //单击任务
    

  189.          }
    

  190.          else if(Su8KeyTouchCnt1>=2)  //连续按了两次以上
    

  191.          {
    

  192.               Su8KeyTouchCnt1=0;    //统计按键次数清零
    

  193.               vGu8SingleKeySec=1;   //单击任务
    

  194. vGu8DoubleKeySec=1;   //双击任务
    

  195.          }
    

  196.       }
    

  197.    }
    


  198. 

  199. }
    


  200. 

  201. void SingleKeyTask(void)    //单击按键任务函数，放在主函数内
    

  202. {
    

  203. if(0==vGu8SingleKeySec)
    

  204. {
    

  205. return; //按键的触发序号是0意味着无按键触发，直接退出当前函数，不执行此函数下面的代码
    

  206. }
    


  207. 

  208. switch(vGu8SingleKeySec) //根据不同的按键触发序号执行对应的代码
    

  209. {
    

  210.    case 1:     //单击任务
    

  211.         //通过Gu8LedStatus的状态切换，来反复切换LED的“灭”与“亮”的状态
    

  212.         if(0==Gu8LedStatus) 
    

  213.         {
    

  214.             Gu8LedStatus=1; //标识并且更改当前LED灯的状态。0就变成1。
    

  215.             LedOpen();   //点亮LED
    

  216. }
    

  217.         else 
    

  218.         {
    

  219.             Gu8LedStatus=0; //标识并且更改当前LED灯的状态。1就变成0。
    

  220.             LedClose();  //关闭LED
    

  221. }
    


  222. 

  223. vGu8SingleKeySec=0;  //响应按键服务处理程序后，按键编号必须清零，避免一致触发
    

  224. break;
    

  225. }
    


  226. 

  227. }
    


  228. 

  229. void DoubleKeyTask(void)    //双击按键任务函数，放在主函数内
    

  230. {
    

  231. if(0==vGu8DoubleKeySec)
    

  232. {
    

  233. return; //按键的触发序号是0意味着无按键触发，直接退出当前函数，不执行此函数下面的代码
    

  234. }
    


  235. 

  236. switch(vGu8DoubleKeySec) //根据不同的按键触发序号执行对应的代码
    

  237. {
    

  238.    case 1:     //双击任务
    


  239. 

  240.         vGu8BeepTimerFlag=0;  
    

  241. vGu16BeepTimerCnt=KEY_VOICE_TIME;  //触发双击后，发出“嘀”一声
    

  242.         vGu8BeepTimerFlag=1;  
    

  243. vGu8DoubleKeySec=0;  //响应按键服务处理程序后，按键编号必须清零，避免一致触发
    

  244. break;
    

  245. }
    


  246. 

  247. }
    


  248.


本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏269 举报

wangxueq 发表于 2017-10-31 22:24 | 显示全部楼层
鼓励 加油！
回复

收藏269 举报

 楼主| jianhong_wu 发表于 2017-11-5 11:24 | 显示全部楼层
第九十四节： 两个独立按键构成的组合按键。

【94.1   组合按键。】




                上图94.1.1  独立按键电路


  
                上图94.1.2  LED电路

              
                上图94.1.3  有源蜂鸣器电路

        组合按键的触发，是指两个按键同时按下时的“非单击”触发。一次组合按键的产生，必然包含了三类按键的触发。比如，K1与K2两个独立按键，当它们产生一次组合按键的操作时，就包含了三类触发：K1单击触发，K2单击触发，K1与K2的组合触发。这三类触发可以看作是底层的按键驱动程序，在按键应用层的任务函数SingleKeyTask和CombinationKeyTask中，可以根据项目的实际需要进行响应。本节程序例程要实现的功能是：（1）K1单击让LED变成“亮”的状态。（2）K2单击让LED变成“灭”的状态。（3）K1与K2的组合按键触发让蜂鸣器发出“嘀”的一声。代码如下：
复制

  1. 

  2. #include "REG52.H"  
    


  3. 

  4. #define KEY_VOICE_TIME   50     //组合按键触发后发出的声音长度  
    

  5. #define KEY_FILTER_TIME  25     //按键滤波的“稳定时间”25ms
    


  6. 

  7. void T0_time();
    

  8. void SystemInitial(void) ;
    

  9. void Delay(unsigned long u32DelayTime) ;
    

  10. void PeripheralInitial(void) ;
    


  11. 

  12. void BeepOpen(void);   
    

  13. void BeepClose(void); 
    

  14. void LedOpen(void);   
    

  15. void LedClose(void); 
    


  16. 

  17. void VoiceScan(void);
    

  18. void KeyScan(void);    //按键识别的驱动函数，放在定时中断里
    

  19. void SingleKeyTask(void);   //单击按键任务函数，放在主函数内
    

  20. void CombinationKeyTask(void);   //组合按键任务函数，放在主函数内
    


  21. 

  22. sbit P3_4=P3^4;       //蜂鸣器
    

  23. sbit P1_4=P1^4;       //LED
    


  24. 

  25. sbit KEY_INPUT1=P2^2;  //K1按键识别的输入口。
    

  26. sbit KEY_INPUT2=P2^1;  //K2按键识别的输入口。
    


  27. 

  28. volatile unsigned char vGu8BeepTimerFlag=0;  
    

  29. volatile unsigned int vGu16BeepTimerCnt=0;  
    


  30. 

  31. volatile unsigned char vGu8SingleKeySec=0;  //单击按键的触发序号
    

  32. volatile unsigned char vGu8CombinationKeySec=0;  //组合按键的触发序号
    


  33. 

  34. void main() 
    

  35. {
    

  36. SystemInitial();            
    

  37. Delay(10000);               
    

  38. PeripheralInitial();      
    

  39.     while(1)  
    

  40. {  
    

  41.    CombinationKeyTask();  //组合按键任务函数
    

  42.    SingleKeyTask();    //单击按键任务函数
    

  43.     }
    

  44. }
    


  45. 

  46. void T0_time() interrupt 1     
    

  47. {
    

  48. VoiceScan();  
    

  49. KeyScan();    //按键识别的驱动函数
    


  50. 

  51. TH0=0xfc;   
    

  52. TL0=0x66;   
    

  53. }
    


  54. 


  55. 

  56. void SystemInitial(void) 
    

  57. {
    

  58. TMOD=0x01;  
    

  59. TH0=0xfc;   
    

  60. TL0=0x66;   
    

  61. EA=1;       
    

  62. ET0=1;      
    

  63. TR0=1;      
    

  64. }
    


  65. 

  66. void Delay(unsigned long u32DelayTime) 
    

  67. {
    

  68.     for(;u32DelayTime>0;u32DelayTime--); 
    

  69. }
    


  70. 

  71. void PeripheralInitial(void) 
    

  72. {
    

  73. LedClose();  //初始化关闭LED
    

  74. }
    


  75. 

  76. void BeepOpen(void)
    

  77. {
    

  78. P3_4=0;  
    

  79. }
    


  80. 

  81. void BeepClose(void)
    

  82. {
    

  83. P3_4=1;  
    

  84. }
    

  85. void LedOpen(void)
    

  86. {
    

  87. P1_4=0;  
    

  88. }
    


  89. 

  90. void LedClose(void)
    

  91. {
    

  92. P1_4=1;  
    

  93. }
    


  94. 

  95. void VoiceScan(void)
    

  96. {
    


  97. 

  98.           static unsigned char Su8Lock=0;  
    


  99. 

  100. if(1==vGu8BeepTimerFlag&&vGu16BeepTimerCnt>0)
    

  101.           {
    

  102.                   if(0==Su8Lock)
    

  103.                   {
    

  104.                    Su8Lock=1;  
    

  105. BeepOpen(); 
    

  106.      }
    

  107.     else  
    

  108. {     
    


  109. 

  110.                        vGu16BeepTimerCnt--;         
    


  111. 

  112.                    if(0==vGu16BeepTimerCnt)
    

  113.                    {
    

  114.                            Su8Lock=0;     
    

  115. BeepClose();  
    

  116.                    }
    


  117. 

  118. }
    

  119.           }         
    

  120. }
    


  121. 


  122. 

  123. /* 注释一：
    

  124. * 组合按键扫描的详细过程：
    

  125. * 第一步：平时只要K1与K2两个按键中有一个没有被按下时，按键的自锁标志,去抖动延时计数器
    

  126. * 一直被清零。
    

  127. * 第二步：一旦两个按键都处于被按下的状态，去抖动延时计数器开始在定时中断函数里累加，在还没
    

  128. *         累加到阀值KEY_FILTER_TIME时，如果在这期间由于受外界干扰或者按键抖动，而使其中一个
    

  129. *         IO口突然瞬间触发成高电平，这个时候马上把延时计数器Su16CombinationKeyTimeCnt
    

  130. *         清零了,这个过程非常巧妙，非常有效地去除瞬间的杂波干扰。
    

  131. * 第三步：如果两个按键按下的时间超过了阀值KEY_FILTER_TIME，马上把自锁标志Su8CombinationKeyLock
    

  132. *         置1，防止按住两个按键不松手后一直触发。并把按键编号vGu8CombinationKeySec赋值，
    

  133. *         触发一次组合按键。
    

  134. * 第四步：等其中一个按键松开后，自锁标志Su8CombinationKeyLock及时清零，为下一次自锁做准备。
    

  135. */
    


  136. 

  137. void KeyScan(void)  //此函数放在定时中断里每1ms扫描一次
    

  138. {
    

  139.    static unsigned char Su8KeyLock1;        
    

  140.    static unsigned int  Su16KeyCnt1;         
    

  141.    static unsigned char Su8KeyLock2;          
    

  142.    static unsigned int  Su16KeyCnt2;           
    


  143. 

  144.    static unsigned char Su8CombinationKeyLock;  //组合按键的自锁
    

  145.    static unsigned int  Su16CombinationKeyCnt;  //组合按键的计时器
    


  146. 


  147. 

  148.    //K1按键与K2按键的组合触发
    

  149.    if(0!=KEY_INPUT1||0!=KEY_INPUT2)//两个按键只要有一个按键没有按下，处于“非组合按键”的状态。
    

  150.    {
    

  151.       Su8CombinationKeyLock=0; //组合按键解锁
    

  152.       Su16CombinationKeyCnt=0;  //组合按键去抖动延时计数器清零，此行非常巧妙，是全场的亮点。      
    

  153.    }
    

  154.    else if(0==Su8CombinationKeyLock)//两个按键被同时按下，且是第一次被按下。此行请看专题分析。
    

  155.    {
    

  156.       Su16CombinationKeyCnt++; //累加定时中断次数
    

  157.       if(Su16CombinationKeyCnt>=KEY_FILTER_TIME) //滤波的“稳定时间”KEY_FILTER_TIME。
    

  158.       {
    

  159.          Su8CombinationKeyLock=1;  //组合按键的自锁,避免一直触发
    

  160.          vGu8CombinationKeySec=1;   //触发K1与K2的组合键操作
    

  161.       }
    

  162.    }
    


  163. 

  164.    //K1按键的单击
    

  165.    if(0!=KEY_INPUT1)
    

  166.    {
    

  167.       Su8KeyLock1=0; 
    

  168.       Su16KeyCnt1=0;      
    

  169.    }
    

  170.    else if(0==Su8KeyLock1)
    

  171.    {
    

  172.       Su16KeyCnt1++;
    

  173.       if(Su16KeyCnt1>=KEY_FILTER_TIME) 
    

  174.       {
    

  175.          Su8KeyLock1=1;  
    

  176.          vGu8SingleKeySec=1;    //触发K1的单击键
    

  177.       }
    

  178.    }
    


  179. 

  180.    //K2按键的单击
    

  181.    if(0!=KEY_INPUT2)
    

  182.    {
    

  183.       Su8KeyLock2=0; 
    

  184.       Su16KeyCnt2=0;       
    

  185.    }
    

  186.    else if(0==Su8KeyLock2)
    

  187.    {
    

  188.       Su16KeyCnt2++; 
    

  189.       if(Su16KeyCnt2>=KEY_FILTER_TIME) 
    

  190.       {
    

  191.          Su8KeyLock2=1;  
    

  192.          vGu8SingleKeySec=2;    //触发K2的单击键
    

  193.       }
    

  194.    }
    


  195. 

  196. }
    


  197. 

  198. void CombinationKeyTask(void)    //组合按键任务函数，放在主函数内
    

  199. {
    

  200. if(0==vGu8CombinationKeySec)
    

  201. {
    

  202. return; //按键的触发序号是0意味着无按键触发，直接退出当前函数，不执行此函数下面的代码
    

  203. }
    


  204. 

  205. switch(vGu8CombinationKeySec) //根据不同的按键触发序号执行对应的代码
    

  206. {
    

  207.    case 1:     //K1与K2的组合按键任务
    


  208. 

  209.         vGu8BeepTimerFlag=0;  
    

  210. vGu16BeepTimerCnt=KEY_VOICE_TIME;  //触发一次组合按键后，发出“嘀”一声
    

  211.         vGu8BeepTimerFlag=1;  
    

  212. vGu8CombinationKeySec=0;  //响应按键服务处理程序后，按键编号必须清零，避免一致触发
    

  213. break;
    

  214. }
    


  215. 

  216. }
    


  217. 

  218. void SingleKeyTask(void)    //单击按键任务函数，放在主函数内
    

  219. {
    

  220. if(0==vGu8SingleKeySec)
    

  221. {
    

  222. return; //按键的触发序号是0意味着无按键触发，直接退出当前函数，不执行此函数下面的代码
    

  223. }
    


  224. 

  225. switch(vGu8SingleKeySec) //根据不同的按键触发序号执行对应的代码
    

  226. {
    

  227.    case 1:     //K1单击任务
    

  228.         LedOpen();    //LED亮
    


  229. 

  230. vGu8SingleKeySec=0;  //响应按键服务处理程序后，按键编号必须清零，避免一致触发
    

  231. break;
    


  232. 

  233.    case 2:     //K2单击任务
    

  234.         LedClose();   //LED灭
    


  235. 

  236. vGu8SingleKeySec=0;  //响应按键服务处理程序后，按键编号必须清零，避免一致触发
    

  237. break;
    


  238. 

  239. }
    


  240. 

  241. }


【94.2   专题分析：else if(0==Su8CombinationKeyLock)。】

        疑问：
复制
  1.    if(0!=KEY_INPUT1||0!=KEY_INPUT2)
    

  2.    {
    

  3.       Su8CombinationKeyLock=0; 
    

  4.       Su16CombinationKeyCnt=0;       
    

  5.    }
    

  6.    else if(0==Su8CombinationKeyLock)//两个按键被同时按下，且是第一次被按下。为什么？
    

  7.    {
    

  8.       Su16CombinationKeyCnt++; 
    

  9.       if(Su16CombinationKeyCnt>=KEY_FILTER_TIME) 
    

  10.       {
    

  11.          Su8CombinationKeyLock=1;  
    

  12.          vGu8CombinationKeySec=1;   
    

  13.       }
    

  14.    }


       解答：
       首先，我们要明白C语言的语法中，
复制
  1. if(条件1)
    

  2. {
    


  3. 

  4. }
    

  5. else if(条件2)
    

  6. {
    


  7. 

  8. }

       以上语句是一对组合语句，不能分开来看。当（条件1）成立的时候，它是绝对不会判断（条件2）的。当（条件1）不成立的时候，才会判断（条件2）。
       回到刚才的问题，当程序执行到（条件2） else if(0==Su8CombinationKeyLock)的时候，就已经默认了（条件1） if(0!=KEY_INPUT1||0!=KEY_INPUT2)不成立，这个条件不成立，就意味着0==KEY_INPUT1和0==KEY_INPUT2，也就是有两个按键被同时按下，因此，这里的else if(0==Su8CombinationKeyLock)等效于else if(0==Su8CombinationKeyLock&&0==KEY_INPUT1&&0==KEY_INPUT2)，而Su8CombinationKeyLock是一个自锁标志位，一旦组合按键被触发后，这个标志位会变1，防止两个按键按住不松手的时候不断触发组合按键。这样，组合按键只能同时按下一次触发一次，任意松开其中一个按键后再同时按下一次两个按键，又触发一次新的组合按键。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏269 举报

 楼主| jianhong_wu 发表于 2017-11-12 15:31 | 显示全部楼层
第九十五节： 两个独立按键的“电脑键盘式”组合按键。

【95.1   “电脑键盘式”组合按键。】




                上图95.1.1  独立按键电路



                上图95.1.2  LED电路

               
                上图95.1.3  有源蜂鸣器电路

        上一节也讲了由K1和K2构成的组合按键，但是这种组合按键是普通的组合按键，因为它们的K1和K2是不分先后顺序的，你先按住K1然后再按K2，或者你先按住K2然后再按K1，效果都一样。本节讲的组合按键是分先后顺序的，比如，像电脑的复制快捷键（Ctrl+C），你必须先按住Ctrl再按住C此时“复制快捷键”才有效，如果你先按住C再按住Ctrl此时“复制快捷键”无效。本节讲的例程就是要实现这个功能，用K1代表C这类“字符数字键”，用K2代表Ctrl这类“辅助按键”，因此，要触发组合键（K2+K1），必须先按住K2再按K1才有效。本节讲的例程功能如下：（1）K1每单击一次，LED要么从“灭”变成“亮”，要么从“亮”变成“灭”，在两种状态之间切换。（2）如果先按住K2再按K1，就认为构造了“电脑键盘式”组合键，蜂鸣器发出“嘀”的一声。代码如下：
复制
  1. #include "REG52.H"  
    


  2. 

  3. #define KEY_VOICE_TIME   50     //组合按键触发后发出的声音长度 50ms  
    

  4. #define KEY_FILTER_TIME  25     //按键滤波的“稳定时间”25ms
    


  5. 

  6. void T0_time();
    

  7. void SystemInitial(void) ;
    

  8. void Delay(unsigned long u32DelayTime) ;
    

  9. void PeripheralInitial(void) ;
    


  10. 

  11. void BeepOpen(void);   
    

  12. void BeepClose(void);
    

  13. void LedOpen(void);   
    

  14. void LedClose(void);
    


  15. 

  16. void VoiceScan(void);
    

  17. void KeyScan(void);    //按键识别的驱动函数，放在定时中断里
    

  18. void SingleKeyTask(void);   //单击按键任务函数，放在主函数内
    

  19. void CombinationKeyTask(void);   //组合按键任务函数，放在主函数内
    


  20. 

  21. sbit P3_4=P3^4;       //蜂鸣器
    

  22. sbit P1_4=P1^4;       //LED
    


  23. 

  24. sbit KEY_INPUT1=P2^2;  //K1按键识别的输入口。
    

  25. sbit KEY_INPUT2=P2^1;  //K2按键识别的输入口。
    


  26. 

  27. volatile unsigned char vGu8BeepTimerFlag=0;  
    

  28. volatile unsigned int vGu16BeepTimerCnt=0;  
    


  29. 

  30. unsigned char Gu8LedStatus=0; //记录LED灯的状态，0代表灭，1代表亮
    


  31. 

  32. volatile unsigned char vGu8SingleKeySec=0;  //单击按键的触发序号
    

  33. volatile unsigned char vGu8CombinationKeySec=0;  //组合按键的触发序号
    


  34. 

  35. void main()
    

  36. {
    

  37. SystemInitial();            
    

  38. Delay(10000);               
    

  39. PeripheralInitial();      
    

  40.     while(1)  
    

  41. {  
    

  42.    CombinationKeyTask();  //组合按键任务函数
    

  43.    SingleKeyTask();       //单击按键任务函数
    

  44.     }
    

  45. }
    


  46. 

  47. void T0_time() interrupt 1     
    

  48. {
    

  49. VoiceScan();  
    

  50. KeyScan();    //按键识别的驱动函数
    


  51. 

  52. TH0=0xfc;   
    

  53. TL0=0x66;   
    

  54. }
    


  55. 


  56. 

  57. void SystemInitial(void)
    

  58. {
    

  59. TMOD=0x01;  
    

  60. TH0=0xfc;   
    

  61. TL0=0x66;   
    

  62. EA=1;      
    

  63. ET0=1;      
    

  64. TR0=1;      
    

  65. }
    


  66. 

  67. void Delay(unsigned long u32DelayTime)
    

  68. {
    

  69.     for(;u32DelayTime>0;u32DelayTime--);
    

  70. }
    


  71. 

  72. void PeripheralInitial(void)
    

  73. {
    

  74. if(0==Gu8LedStatus)
    

  75. {
    

  76. LedClose();  
    

  77. }
    

  78. else
    

  79. {
    

  80. LedOpen();  
    

  81. }
    

  82. }
    


  83. 

  84. void BeepOpen(void)
    

  85. {
    

  86. P3_4=0;  
    

  87. }
    


  88. 

  89. void BeepClose(void)
    

  90. {
    

  91. P3_4=1;  
    

  92. }
    

  93. void LedOpen(void)
    

  94. {
    

  95. P1_4=0;  
    

  96. }
    


  97. 

  98. void LedClose(void)
    

  99. {
    

  100. P1_4=1;  
    

  101. }
    


  102. 

  103. void VoiceScan(void)
    

  104. {
    


  105. 

  106.           static unsigned char Su8Lock=0;  
    


  107. 

  108. if(1==vGu8BeepTimerFlag&&vGu16BeepTimerCnt>0)
    

  109.           {
    

  110.                   if(0==Su8Lock)
    

  111.                   {
    

  112.                    Su8Lock=1;  
    

  113. BeepOpen();
    

  114.      }
    

  115.     else  
    

  116. {     
    


  117. 

  118.                        vGu16BeepTimerCnt--;         
    


  119. 

  120.                    if(0==vGu16BeepTimerCnt)
    

  121.                    {
    

  122.                            Su8Lock=0;     
    

  123. BeepClose();  
    

  124.                    }
    


  125. 

  126. }
    

  127.           }         
    

  128. }
    


  129. 


  130. 

  131. /* 注释一：
    

  132. * “电脑键盘式”组合按键扫描的详细过程：
    

  133. * 第一步：K2与K1构成的组合按键触发是融合在K1单击按键程序里的，只需稍微更改一下K1单击的程序
    

  134. *         ，就可以兼容到K2与K1构成的“电脑键盘式”组合按键。平时只要K1没有被按下时，按
    

  135. *         键的自锁标志Su8KeyLock1和去抖动延时计数器Su16KeyCnt1一直被清零。
    

  136. * 第二步：一旦K1按键被按下，去抖动延时计数器Su16KeyCnt1开始在定时中断函数里累加，在还没
    

  137. *         累加到阀值KEY_FILTER_TIME时，如果在这期间由于受外界干扰或者按键抖动，而使
    

  138. *         IO口突然瞬间触发成高电平，这个时候马上把延时计数器Su16KeyCnt1清零了,
    

  139. *         这个过程非常巧妙，非常有效地去除瞬间的杂波干扰。
    

  140. * 第三步：如果K1按键按下的时间超过了阀值KEY_FILTER_TIME，马上把自锁标志Su8KeyLock1置1，
    

  141. *         防止按住按键不松手后一直触发，此时才开始判断一次K2按键的电平状态，如果K2为低电
    

  142. *         平就认为是组合按键，并给按键编号vGu8CombinationKeySec赋值，否则，就认为是K1的单击
    

  143. *         按键，并给按键编号vGu8SingleKeySec赋值。
    

  144. * 第四步：等K1按键松开后，自锁标志Su8KeyLock1及时清零，为下一次自锁做准备。
    

  145. */
    


  146. 

  147. void KeyScan(void)  //此函数放在定时中断里每1ms扫描一次
    

  148. {
    

  149.    static unsigned char Su8KeyLock1;        
    

  150.    static unsigned int  Su16KeyCnt1;         
    


  151. 


  152. 

  153.    //K1的单击，或者K2与K1构成的“电脑键盘式组合按键”。
    

  154.    if(0!=KEY_INPUT1)//单个K1按键没有按下，及时清零一些标志。
    

  155.    {
    

  156.       Su8KeyLock1=0; //按键解锁
    

  157.       Su16KeyCnt1=0;  //去抖动延时计数器清零，此行非常巧妙，是全场的亮点。      
    

  158.    }
    

  159.    else if(0==Su8KeyLock1)//单个按键K1被按下
    

  160.    {
    

  161.       Su16KeyCnt1++; //累加定时中断次数
    

  162.       if(Su16KeyCnt1>=KEY_FILTER_TIME) //滤波的“稳定时间”KEY_FILTER_TIME。
    

  163.       {
    

  164.          if(0==KEY_INPUT2)  //此时才开始判断一次K2的电平状态，为低电平则是组合按键。
    

  165.          {
    

  166.             Su8KeyLock1=1;  
    

  167.             vGu8CombinationKeySec=1;  //组合按键的触发
    

  168. }
    

  169. else   
    

  170.          {
    

  171.             Su8KeyLock1=1;  
    

  172.             vGu8SingleKeySec=1;    //K1单击按键的触发
    

  173. }
    

  174.       }
    

  175.    }
    

  176. }
    


  177. 

  178. void CombinationKeyTask(void)    //组合按键任务函数，放在主函数内
    

  179. {
    

  180. if(0==vGu8CombinationKeySec)
    

  181. {
    

  182. return; //按键的触发序号是0意味着无按键触发，直接退出当前函数，不执行此函数下面的代码
    

  183. }
    


  184. 

  185. switch(vGu8CombinationKeySec) //根据不同的按键触发序号执行对应的代码
    

  186. {
    

  187.    case 1:     //K1与K2的组合按键任务
    


  188. 

  189.         vGu8BeepTimerFlag=0;  
    

  190. vGu16BeepTimerCnt=KEY_VOICE_TIME;  //触发一次组合按键后，发出“嘀”一声
    

  191.         vGu8BeepTimerFlag=1;  
    

  192. vGu8CombinationKeySec=0;  //响应按键服务处理程序后，按键编号必须清零，避免一致触发
    

  193. break;
    

  194. }
    


  195. 

  196. }
    


  197. 

  198. void SingleKeyTask(void)    //单击按键任务函数，放在主函数内
    

  199. {
    

  200. if(0==vGu8SingleKeySec)
    

  201. {
    

  202. return; //按键的触发序号是0意味着无按键触发，直接退出当前函数，不执行此函数下面的代码
    

  203. }
    


  204. 

  205. switch(vGu8SingleKeySec) //根据不同的按键触发序号执行对应的代码
    

  206. {
    

  207.    case 1:     //K1单击任务
    

  208. if(0==Gu8LedStatus)
    

  209. {
    

  210. Gu8LedStatus=1;
    

  211. LedOpen();    //LED亮   
    

  212. }
    

  213. else
    

  214. {
    

  215. Gu8LedStatus=0;
    

  216. LedClose();    //LED灭   
    

  217. }
    


  218. 

  219. vGu8SingleKeySec=0;  //响应按键服务处理程序后，按键编号必须清零，避免一致触发
    

  220. break;
    

  221. }
    


  222. 

  223. }



本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏269 举报

评论

龙魔123
应该在KeyScan（）函数中在加一个K2是在K1按下前或者按下后按下的一个状态变量来进行判断。  发表于 2018-12-8 21:36
龙魔123
此处代码如果是K2先提前按下，在按K1，蜂鸣器也是会响的  发表于 2018-12-8 21:21

评分

参与人数 1威望 +1 收起 理由
龙魔123 + 1 很给力!

查看全部评分

 楼主| jianhong_wu 发表于 2017-11-26 11:40 | 显示全部楼层
第九十七节： 独立按键按住不松手的连续均匀触发。

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




                上图97.1.1  独立按键电路


                 
                上图97.1.2  灌入式驱动8个LED

               
                上图97.1.3  有源蜂鸣器电路

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

  1. 

  2. #include "REG52.H"  
    


  3. 

  4. #define KEY_VOICE_TIME   50     
    


  5. 

  6. #define KEY_SHORT_TIME  25      //按键单击的“滤波”时间25ms
    

  7. #define KEY_ENTER_CONTINUITY_TIME    300  //按键“从单击进入连击”的间隔时间300ms
    

  8. #define KEY_CONTINUITY_TIME    80  //按键“连击”的间隔时间80ms
    


  9. 

  10. #define BUS_P0    P0     //8个LED灯一一对应单片机的P0口总线
    


  11. 

  12. void T0_time();
    

  13. void SystemInitial(void) ;
    

  14. void Delay(unsigned long u32DelayTime) ;
    

  15. void PeripheralInitial(void) ;
    


  16. 

  17. void BeepOpen(void);   
    

  18. void BeepClose(void); 
    


  19. 

  20. void VoiceScan(void);
    

  21. void KeyScan(void);    
    

  22. void KeyTask(void);   
    

  23. void DisplayTask(void);   //显示的任务函数（LED显示状态）
    


  24. 

  25. sbit P3_4=P3^4;       //蜂鸣器
    


  26. 

  27. sbit KEY_INPUT1=P2^2;  //K1按键识别的输入口。
    

  28. sbit KEY_INPUT2=P2^1;  //K2按键识别的输入口。
    


  29. 

  30. volatile unsigned char vGu8BeepTimerFlag=0;  
    

  31. volatile unsigned int vGu16BeepTimerCnt=0;  
    


  32. 

  33. unsigned char Gu8LedStatus=0; //LED灯的状态
    

  34. unsigned char Gu8DisplayUpdate=1; //显示的刷新标志
    


  35. 

  36. volatile unsigned char vGu8KeySec=0;  //按键的触发序号
    

  37. volatile unsigned char vGu8ShieldVoiceFlag=0;  //屏蔽声音的标志
    


  38. 

  39. void main() 
    

  40. {
    

  41. SystemInitial();            
    

  42. Delay(10000);               
    

  43. PeripheralInitial();      
    

  44.     while(1)  
    

  45. {  
    

  46.     KeyTask();       //按键的任务函数
    

  47. DisplayTask();   //显示的任务函数（LED显示状态）
    

  48.     }
    

  49. }
    


  50. 


  51. 

  52. /* 注释一：
    

  53. * Gu8DisplayUpdate这类“显示刷新变量”在“显示框架”里是很常见的，而且屡用屡爽。
    

  54. * 目的是，既能及时刷新显示，又能避免主函数“不断去执行显示代码”而影响程序效率。
    

  55. */
    


  56. 

  57. void DisplayTask(void)   //显示的任务函数（LED显示状态）
    

  58. {
    

  59. if(1==Gu8DisplayUpdate)  //需要刷新一次显示
    

  60. {
    

  61. Gu8DisplayUpdate=0;  //及时清零，避免主函数“不断去执行显示代码”而影响程序效率
    


  62. 

  63. //Gu8LedStatus是左移的位数，范围（0至7），决定了跑马灯的显示状态。
    

  64. BUS_P0=~(1<<Gu8LedStatus);  //“左移<<”之后的“取反~”，因为LED电路是灌入式驱动方式。
    

  65. }
    

  66. }
    


  67. 

  68. /* 注释二：
    

  69. * 按键“连续均匀触发”的识别过程：
    

  70. * 第一步：平时只要K1没有被按下，按键的自锁标志Su8KeyLock1、去抖动延时计数器Su16KeyCnt1、
    

  71. *         连击计数器Su16KeyContinuityCnt1，一直被清零。
    

  72. * 第二步：一旦K1按键被按下，去抖动延时计数器Su16KeyCnt1开始在定时中断函数里累加，在还没
    

  73. *         累加到阀值KEY_SHORT_TIME时，如果在这期间由于受外界干扰或者按键抖动，
    

  74. *         而使IO口突然瞬间触发成高电平，这个时候马上把延时计数器Su16KeyCnt1清零,
    

  75. *         这个过程非常巧妙，非常有效地去除瞬间的杂波干扰。
    

  76. * 第三步：如果K1按键按下的时间超过了阀值KEY_SHORT_TIME，则触发一次“单击”， 同时，马上把自锁
    

  77. *         标志Su8KeyLock1置1防止按住按键不松手后一直触发，并且把计数器Su16KeyCnt1清零为了下
    

  78. *         一步用来累加“从单击进入连击的间隔时间1000ms”。如果此时还没有松手，直到发现按下的时
    

  79. *         间超过“从单击进入连击的间隔时间”阀值KEY_ENTER_CONTINUITY_TIME时，从此进入“连击”
    

  80. *         的模式，连击计数器Su16KeyContinuityCnt1开始累加，每到达一次阀值
    

  81. *         KEY_CONTINUITY_TIME就触发1次按键，为了屏蔽按键声音及时把vGu8ShieldVoiceFlag也置1，
    

  82. *         同时，Su16KeyContinuityCnt1马上清零为继续连击作准备。
    

  83. * 第四步：等K1按键松手后，自锁标志Su8KeyLock1、去抖动延时计数器Su16KeyCnt1、
    

  84. *         连击计数器Su16KeyContinuityCnt1，及时清零，为下一次按键触发做准备。
    

  85. */
    


  86. 

  87. void KeyScan(void)  //此函数放在定时中断里每1ms扫描一次
    

  88. {
    

  89.    static unsigned char Su8KeyLock1;        
    

  90.    static unsigned int  Su16KeyCnt1;  
    

  91.    static unsigned int  Su16KeyContinuityCnt1;  //连击计数器
    


  92. 

  93.    static unsigned char Su8KeyLock2;        
    

  94.    static unsigned int  Su16KeyCnt2;  
    

  95.    static unsigned int  Su16KeyContinuityCnt2;  //连击计数器
    


  96. 

  97.    //K1按键
    

  98.    if(0!=KEY_INPUT1)//单个K1按键没有按下，及时清零一些标志。
    

  99.    {
    

  100.       Su8KeyLock1=0; //按键解锁
    

  101.       Su16KeyCnt1=0;  //去抖动延时计数器清零，此行非常巧妙，是全场的亮点。
    

  102. Su16KeyContinuityCnt1=0;  //连击计数器  
    

  103.    }
    

  104.    else if(0==Su8KeyLock1)//单个按键K1被按下
    

  105.    {
    

  106.       Su16KeyCnt1++; //累加定时中断次数，每一次累加额度是1ms
    

  107.       if(Su16KeyCnt1>=KEY_SHORT_TIME) //按键的“滤波”时间25ms
    

  108.       {
    

  109.             Su8KeyLock1=1;      //“自锁”
    

  110.             vGu8KeySec=1;       //触发一次K1按键      
    

  111.             Su16KeyCnt1=0;      //清零，为了下一步用来累加“从单击进入连击的间隔时间300ms”
    

  112.       }
    

  113.    }
    

  114.    else if(Su16KeyCnt1<=KEY_ENTER_CONTINUITY_TIME)//按住不松手累加到300ms
    

  115.    {
    

  116.       Su16KeyCnt1++; //累加定时中断次数，每一次累加额度是1ms
    

  117.    }
    

  118.    else  //按住累加到300ms后仍然不放手，这个时候进入有节奏的连续触发
    

  119.    {
    

  120.        Su16KeyContinuityCnt1++; //连击计数器开始累加，每一次累加额度是1ms
    

  121.        if(Su16KeyContinuityCnt1>=KEY_CONTINUITY_TIME)  //按住没松手，每0.08秒就触发一次
    

  122.        {
    

  123.             Su16KeyContinuityCnt1=0; //清零，为了继续连击。
    

  124.             vGu8KeySec=1;       //触发一次K1按键   
    

  125. vGu8ShieldVoiceFlag=1;  //把当前按键触发的声音屏蔽掉
    

  126.        }
    


  127. 

  128.   }
    


  129. 

  130.    //K2按键
    

  131.    if(0!=KEY_INPUT2)
    

  132.    {
    

  133.       Su8KeyLock2=0; 
    

  134.       Su16KeyCnt2=0;  
    

  135. Su16KeyContinuityCnt2=0;   
    

  136.    }
    

  137.    else if(0==Su8KeyLock2)
    

  138.    {
    

  139.       Su16KeyCnt2++; 
    

  140.       if(Su16KeyCnt2>=KEY_SHORT_TIME) 
    

  141.       {
    

  142.             Su8KeyLock2=1;     
    

  143.             vGu8KeySec=2;       //触发一次K2按键      
    

  144.             Su16KeyCnt2=0;      
    

  145.       }
    

  146.    }
    

  147.    else if(Su16KeyCnt2<=KEY_ENTER_CONTINUITY_TIME)
    

  148.    {
    

  149.       Su16KeyCnt2++; 
    

  150.    }
    

  151.    else 
    

  152.    {
    

  153.        Su16KeyContinuityCnt2++; 
    

  154.        if(Su16KeyContinuityCnt2>=KEY_CONTINUITY_TIME)  
    

  155.        {
    

  156.             Su16KeyContinuityCnt2=0; 
    

  157.             vGu8KeySec=2;       //触发一次K2按键   
    

  158. vGu8ShieldVoiceFlag=1;  //把当前按键触发的声音屏蔽掉
    

  159.        }
    


  160. 

  161.   }
    

  162. }
    


  163. 

  164. void KeyTask(void)    //按键任务函数，放在主函数内
    

  165. {
    

  166. if(0==vGu8KeySec)
    

  167. {
    

  168. return; //按键的触发序号是0意味着无按键触发，直接退出当前函数，不执行此函数下面的代码
    

  169. }
    


  170. 

  171. switch(vGu8KeySec) //根据不同的按键触发序号执行对应的代码
    

  172. {
    

  173.    case 1:     //K1触发的任务
    

  174.         if(Gu8LedStatus>0)
    

  175. {
    

  176. Gu8LedStatus--;  //控制LED“往左边跑”
    

  177. Gu8DisplayUpdate=1;  //刷新显示
    

  178. }
    


  179. 

  180.         if(0==vGu8ShieldVoiceFlag) //声音没有被屏蔽
    

  181. {
    

  182.                 vGu8BeepTimerFlag=0;  
    

  183. vGu16BeepTimerCnt=KEY_VOICE_TIME;  //触发一次“长按”后，发出“嘀”一声
    

  184.                 vGu8BeepTimerFlag=1;  
    

  185.             }
    


  186. 

  187. vGu8ShieldVoiceFlag=0;  //及时把屏蔽标志清零，避免平时正常的单击声音也被淹没。
    

  188. vGu8KeySec=0;  //响应按键服务处理程序后，按键编号必须清零，避免一致触发
    

  189. break;
    


  190. 

  191.    case 2:     //K2触发的任务
    

  192.         if(Gu8LedStatus<7)
    

  193. {
    

  194. Gu8LedStatus++;  //控制LED“往右边跑”
    

  195. Gu8DisplayUpdate=1;  //刷新显示
    

  196. }
    


  197. 

  198.         if(0==vGu8ShieldVoiceFlag) //声音没有被屏蔽
    

  199. {
    

  200.                 vGu8BeepTimerFlag=0;  
    

  201. vGu16BeepTimerCnt=KEY_VOICE_TIME;  //触发一次“长按”后，发出“嘀”一声
    

  202.                 vGu8BeepTimerFlag=1;  
    

  203.             }
    


  204. 

  205. vGu8ShieldVoiceFlag=0;  //及时把屏蔽标志清零，避免平时正常的单击声音也被淹没。
    

  206. vGu8KeySec=0;  //响应按键服务处理程序后，按键编号必须清零，避免一致触发
    

  207. break;
    


  208. 

  209. }
    

  210. }
    


  211. 


  212. 


  213. 

  214. void T0_time() interrupt 1     
    

  215. {
    

  216. VoiceScan();  
    

  217. KeyScan();    //按键识别的驱动函数
    


  218. 

  219. TH0=0xfc;   
    

  220. TL0=0x66;   
    

  221. }
    


  222. 


  223. 

  224. void SystemInitial(void) 
    

  225. {
    

  226. TMOD=0x01;  
    

  227. TH0=0xfc;   
    

  228. TL0=0x66;   
    

  229. EA=1;       
    

  230. ET0=1;      
    

  231. TR0=1;      
    

  232. }
    


  233. 

  234. void Delay(unsigned long u32DelayTime) 
    

  235. {
    

  236.     for(;u32DelayTime>0;u32DelayTime--); 
    

  237. }
    


  238. 

  239. void PeripheralInitial(void) 
    

  240. {
    


  241. 

  242. }
    


  243. 

  244. void BeepOpen(void)
    

  245. {
    

  246. P3_4=0;  
    

  247. }
    


  248. 

  249. void BeepClose(void)
    

  250. {
    

  251. P3_4=1;  
    

  252. }
    


  253. 

  254. void VoiceScan(void)
    

  255. {
    


  256. 

  257.           static unsigned char Su8Lock=0;  
    


  258. 

  259. if(1==vGu8BeepTimerFlag&&vGu16BeepTimerCnt>0)
    

  260.           {
    

  261.                   if(0==Su8Lock)
    

  262.                   {
    

  263.                    Su8Lock=1;  
    

  264. BeepOpen(); 
    

  265.      }
    

  266.     else  
    

  267. {     
    


  268. 

  269.                        vGu16BeepTimerCnt--;         
    


  270. 

  271.                    if(0==vGu16BeepTimerCnt)
    

  272.                    {
    

  273.                            Su8Lock=0;     
    

  274. BeepClose();  
    

  275.                    }
    


  276. 

  277. }
    

  278.           }         
    

  279. }


本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏269 举报

一路向北lm 发表于 2017-11-26 12:42 | 显示全部楼层
感谢分享，这么全的资料，大家有福了。
回复

收藏269 举报

arima 发表于 2017-11-26 23:26 | 显示全部楼层
看着这么详细的资料,也是一种享受....

持之以恒,佩服!!!!

加油!!!!
回复

收藏269 举报

 楼主| jianhong_wu 发表于 2017-12-7 11:40 | 显示全部楼层
第九十八节： 独立按键按住不松手的“先加速后匀速”的触发。

【98.1   “先加速后匀速”的触发。】




                上图98.1.1  独立按键电路


                 
                上图98.1.2  灌入式驱动8个LED

               
                上图98.1.3  有源蜂鸣器电路

        当“连续加”或者“连续减”的数据范围很大的时候，就需要按键的加速与匀速相结合的触发方式。“加速”是指按住按键不松手，按键刚开始触发是从慢到快的渐进过程，当“加速”到某个特别快的速度的时候，就“不再加速”，而是以该“恒定高速”进行“连续匀速”触发。这种触发方式，“加速”和“匀速”是相辅相成缺一不可的，为什么？假如没有“加速”只有“匀速”，那么刚按下按键就直接以最高速的“匀速”进行，就会跑过头，缺乏微调功能；而假如没有“匀速”只有“加速”，那么按下按键不松手后，速度就会一直不断飙升，最后失控过冲。
        本节例程实现的功能如下：
       （1）要更改一个“设置参数”（一个全局变量），参数的范围是0到800。
       （2）8个受“设置参数”控制的跑马灯在某一时刻只有1个LED亮，每触发一次K1按键，该“设置参数”就自减1，最小值为0；相反，每触发一次K2按键，该“设置参数”就自加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）按键每“单击”一次蜂鸣器就鸣叫一次，但是，当按键“从单击进入连击”后，蜂鸣器就不鸣叫。
复制

  1. 

  2. #include "REG52.H"  
    


  3. 

  4. #define KEY_VOICE_TIME   50     
    


  5. 

  6. #define KEY_SHORT_TIME  25      //按键单击的“滤波”时间
    

  7. #define KEY_ENTER_CONTINUITY_TIME    300  //按键“从单击进入连击”的间隔时间
    

  8. #define KEY_CONTINUITY_INITIAL_TIME    80  //按键“连击”起始的预设间隔时间
    

  9. #define KEY_SUB_DT_TIME     8      //按键在“加速”时每次减小的时间。
    

  10. #define KEY_CONTINUITY_MIN_TIME   10  //按键时间减小到最后的“匀速”间隔时间。
    


  11. 


  12. 

  13. #define BUS_P0    P0     //8个LED灯一一对应单片机的P0口总线
    


  14. 

  15. void T0_time();
    

  16. void SystemInitial(void) ;
    

  17. void Delay(unsigned long u32DelayTime) ;
    

  18. void PeripheralInitial(void) ;
    


  19. 

  20. void BeepOpen(void);   
    

  21. void BeepClose(void); 
    


  22. 

  23. void VoiceScan(void);
    

  24. void KeyScan(void);    
    

  25. void KeyTask(void);   
    

  26. void DisplayTask(void);   //显示的任务函数（LED显示状态）
    


  27. 

  28. sbit P3_4=P3^4;       //蜂鸣器
    


  29. 

  30. sbit KEY_INPUT1=P2^2;  //K1按键识别的输入口。
    

  31. sbit KEY_INPUT2=P2^1;  //K2按键识别的输入口。
    


  32. 

  33. volatile unsigned char vGu8BeepTimerFlag=0;  
    

  34. volatile unsigned int vGu16BeepTimerCnt=0;  
    


  35. 

  36. unsigned int Gu16SetData=0; //“设置参数”。范围从0到800。LED灯反映该当前值的范围状态
    

  37. unsigned char Gu8DisplayUpdate=1; //显示的刷新标志
    


  38. 

  39. volatile unsigned char vGu8KeySec=0;  //按键的触发序号
    

  40. volatile unsigned char vGu8ShieldVoiceFlag=0;  //屏蔽声音的标志
    


  41. 

  42. void main() 
    

  43. {
    

  44. SystemInitial();            
    

  45. Delay(10000);               
    

  46. PeripheralInitial();      
    

  47.     while(1)  
    

  48. {  
    

  49.     KeyTask();       //按键的任务函数
    

  50. DisplayTask();   //显示的任务函数（LED显示状态）
    

  51.     }
    

  52. }
    


  53. 


  54. 

  55. /* 注释一：
    

  56. * Gu8DisplayUpdate这类“显示刷新变量”在“显示框架”里是很常见的，而且屡用屡爽。
    

  57. * 目的是，既能及时刷新显示，又能避免主函数“不断去执行显示代码”而影响程序效率。
    

  58. */
    

  59. void DisplayTask(void)   //显示的任务函数（LED显示状态）
    

  60. {
    

  61. if(1==Gu8DisplayUpdate)  //需要刷新一次显示
    

  62. {
    

  63. Gu8DisplayUpdate=0;  //及时清零，避免主函数“不断去执行显示代码”而影响程序效率
    


  64. 

  65.         if(Gu16SetData<100)
    

  66. {
    

  67. BUS_P0=~(1<<0);  //第0个灯亮
    

  68. }
    

  69.         else if(Gu16SetData<200)
    

  70. {
    

  71. BUS_P0=~(1<<1);  //第1个灯亮
    

  72. }
    

  73.         else if(Gu16SetData<300)
    

  74. {
    

  75. BUS_P0=~(1<<2);  //第2个灯亮
    

  76. }
    

  77.         else if(Gu16SetData<400)
    

  78. {
    

  79. BUS_P0=~(1<<3);  //第3个灯亮
    

  80. }
    

  81.         else if(Gu16SetData<500)
    

  82. {
    

  83. BUS_P0=~(1<<4);  //第4个灯亮
    

  84. }
    

  85.         else if(Gu16SetData<600)
    

  86. {
    

  87. BUS_P0=~(1<<5);  //第5个灯亮
    

  88. }
    

  89.         else if(Gu16SetData<700)
    

  90. {
    

  91. BUS_P0=~(1<<6);  //第6个灯亮
    

  92. }
    

  93.         else
    

  94. {
    

  95. BUS_P0=~(1<<7);  //第7个灯亮
    

  96. }
    

  97. }
    

  98. }
    


  99. 

  100. /* 注释二：
    

  101. * 按键“先加速后匀速”的识别过程：
    

  102. * 第一步：每次按一次就触发一次“单击”，如果按下去到松手的时间不超过1秒，则不会进入
    

  103. *        “连击”模式。
    

  104. * 第二步：如果按下去不松手的时间超过1秒，则进入“连击”模式。按键触发的节奏
    

  105. *         不断加快，直至到达某个极限值，然后以此极限值间隔匀速触发。这就是“先加速后匀速”。
    

  106. */
    


  107. 

  108. void KeyScan(void)  //此函数放在定时中断里每1ms扫描一次
    

  109. {
    

  110.    static unsigned char Su8KeyLock1;        
    

  111.    static unsigned int  Su16KeyCnt1;  
    

  112.    static unsigned int  Su16KeyContinuityCnt1;  //连击计数器
    

  113.    static unsigned int  Su16KeyContinuityTime1=KEY_CONTINUITY_INITIAL_TIME;  //动态时间阀值
    


  114. 

  115.    static unsigned char Su8KeyLock2;        
    

  116.    static unsigned int  Su16KeyCnt2;  
    

  117.    static unsigned int  Su16KeyContinuityCnt2;  //连击计数器
    

  118.    static unsigned int  Su16KeyContinuityTime2=KEY_CONTINUITY_INITIAL_TIME;  //动态时间阀值
    


  119. 

  120.    //K1按键
    

  121.    if(0!=KEY_INPUT1)//单个K1按键没有按下，及时清零一些标志。
    

  122.    {
    

  123.       Su8KeyLock1=0; //按键解锁
    

  124.       Su16KeyCnt1=0;  //去抖动延时计数器清零，此行非常巧妙，是全场的亮点。
    

  125. Su16KeyContinuityCnt1=0;  //连击计数器  
    

  126. Su16KeyContinuityTime1=KEY_CONTINUITY_INITIAL_TIME;  //动态时间阀值。重装初始值。
    

  127.    }
    

  128.    else if(0==Su8KeyLock1)//单个按键K1被按下
    

  129.    {
    

  130.       Su16KeyCnt1++; //累加定时中断次数，每一次累加额度是1ms
    

  131.       if(Su16KeyCnt1>=KEY_SHORT_TIME) //按键的“滤波”时间25ms
    

  132.       {
    

  133.             Su8KeyLock1=1;      //“自锁”
    

  134.             vGu8KeySec=1;       //触发一次K1按键      
    

  135.             Su16KeyCnt1=0;      //清零，为了下一步用来累加“从单击进入连击的间隔时间300ms”
    

  136.       }
    

  137.    }
    

  138.    else if(Su16KeyCnt1<=KEY_ENTER_CONTINUITY_TIME)//按住不松手累加到300ms
    

  139.    {
    

  140.       Su16KeyCnt1++; //累加定时中断次数，每一次累加额度是1ms
    

  141.    }
    

  142.    else  //按住累加到300ms后仍然不放手，这个时候进入有节奏的连续触发
    

  143.    {
    

  144.        Su16KeyContinuityCnt1++; //连击计数器开始累加，每一次累加额度是1ms
    

  145.        if(Su16KeyContinuityCnt1>=Su16KeyContinuityTime1)  //按住没松手，每隔一会就触发一次
    

  146.        {
    

  147.             Su16KeyContinuityCnt1=0; //清零，为了继续连击。
    

  148.             vGu8KeySec=1;       //触发一次K1按键   
    

  149. vGu8ShieldVoiceFlag=1;  //把当前按键触发的声音屏蔽掉
    

  150. if(Su16KeyContinuityTime1>=KEY_SUB_DT_TIME)
    

  151. {
    

  152.     //此数值不断被减小，按键的触发速度就不断变快
    

  153. Su16KeyContinuityTime1=Su16KeyContinuityTime1-KEY_SUB_DT_TIME;//变快节奏
    

  154. }
    


  155. 

  156. if(Su16KeyContinuityTime1<KEY_CONTINUITY_MIN_TIME) //最小间隔时间就是“高速匀速”
    

  157. {
    

  158. Su16KeyContinuityTime1=KEY_CONTINUITY_MIN_TIME; //最后以此最高速进行“匀速”
    

  159. }
    


  160. 

  161.        }
    


  162. 

  163.   }
    


  164. 

  165.    //K2按键
    

  166.    if(0!=KEY_INPUT2)
    

  167.    {
    

  168.       Su8KeyLock2=0; 
    

  169.       Su16KeyCnt2=0;  
    

  170. Su16KeyContinuityCnt2=0; 
    

  171. Su16KeyContinuityTime2=KEY_CONTINUITY_INITIAL_TIME;
    

  172.    }
    

  173.    else if(0==Su8KeyLock2)
    

  174.    {
    

  175.       Su16KeyCnt2++; 
    

  176.       if(Su16KeyCnt2>=KEY_SHORT_TIME) 
    

  177.       {
    

  178.             Su8KeyLock2=1;      
    

  179.             vGu8KeySec=2;       //触发一次K2按键      
    

  180.             Su16KeyCnt2=0;           
    

  181.       }
    

  182.    }
    

  183.    else if(Su16KeyCnt2<=KEY_ENTER_CONTINUITY_TIME)
    

  184.    {
    

  185.       Su16KeyCnt2++; 
    

  186.    }
    

  187.    else 
    

  188.    {
    

  189.        Su16KeyContinuityCnt2++; 
    

  190.        if(Su16KeyContinuityCnt2>=Su16KeyContinuityTime2)
    

  191.        {
    

  192.             Su16KeyContinuityCnt2=0;
    

  193.             vGu8KeySec=2;       //触发一次K2按键   
    

  194. vGu8ShieldVoiceFlag=1; 
    

  195. if(Su16KeyContinuityTime2>=KEY_SUB_DT_TIME)
    

  196. {
    

  197. Su16KeyContinuityTime2=Su16KeyContinuityTime2-KEY_SUB_DT_TIME;
    

  198. }
    


  199. 

  200. if(Su16KeyContinuityTime2<KEY_CONTINUITY_MIN_TIME) 
    

  201. {
    

  202. Su16KeyContinuityTime2=KEY_CONTINUITY_MIN_TIME;
    

  203. }
    

  204.        }
    

  205.   }
    

  206. }
    


  207. 

  208. void KeyTask(void)    //按键任务函数，放在主函数内
    

  209. {
    

  210. if(0==vGu8KeySec)
    

  211. {
    

  212. return; //按键的触发序号是0意味着无按键触发，直接退出当前函数，不执行此函数下面的代码
    

  213. }
    


  214. 

  215. switch(vGu8KeySec) //根据不同的按键触发序号执行对应的代码
    

  216. {
    

  217.    case 1:     //K1触发的任务
    

  218.         if(Gu16SetData>0)
    

  219. {
    

  220. Gu16SetData--;     //“设置参数”
    

  221. Gu8DisplayUpdate=1;  //刷新显示
    

  222. }
    


  223. 

  224.         if(0==vGu8ShieldVoiceFlag) //声音没有被屏蔽
    

  225. {
    

  226.                 vGu8BeepTimerFlag=0;  
    

  227. vGu16BeepTimerCnt=KEY_VOICE_TIME;  //发出“嘀”一声
    

  228.                 vGu8BeepTimerFlag=1;  
    

  229.             }
    


  230. 

  231. vGu8ShieldVoiceFlag=0;  //及时把屏蔽标志清零，避免平时正常的单击声音也被淹没。
    

  232. vGu8KeySec=0;  //响应按键服务处理程序后，按键编号必须清零，避免一致触发
    

  233. break;
    


  234. 

  235.    case 2:     //K2触发的任务
    

  236.         if(Gu16SetData<800)
    

  237. {
    

  238. Gu16SetData++;       //“设置参数”
    

  239. Gu8DisplayUpdate=1;  //刷新显示
    

  240. }
    


  241. 

  242.         if(0==vGu8ShieldVoiceFlag) //声音没有被屏蔽
    

  243. {
    

  244.                 vGu8BeepTimerFlag=0;  
    

  245. vGu16BeepTimerCnt=KEY_VOICE_TIME;  //发出“嘀”一声
    

  246.                 vGu8BeepTimerFlag=1;  
    

  247.             }
    


  248. 

  249. vGu8ShieldVoiceFlag=0;  //及时把屏蔽标志清零，避免平时正常的单击声音也被淹没。
    

  250. vGu8KeySec=0;  //响应按键服务处理程序后，按键编号必须清零，避免一致触发
    

  251. break;
    


  252. 

  253. }
    

  254. }
    


  255. 


  256. 


  257. 

  258. void T0_time() interrupt 1     
    

  259. {
    

  260. VoiceScan();  
    

  261. KeyScan();    //按键识别的驱动函数
    


  262. 

  263. TH0=0xfc;   
    

  264. TL0=0x66;   
    

  265. }
    


  266. 


  267. 

  268. void SystemInitial(void) 
    

  269. {
    

  270. TMOD=0x01;  
    

  271. TH0=0xfc;   
    

  272. TL0=0x66;   
    

  273. EA=1;       
    

  274. ET0=1;      
    

  275. TR0=1;      
    

  276. }
    


  277. 

  278. void Delay(unsigned long u32DelayTime) 
    

  279. {
    

  280.     for(;u32DelayTime>0;u32DelayTime--); 
    

  281. }
    


  282. 

  283. void PeripheralInitial(void) 
    

  284. {
    


  285. 

  286. }
    


  287. 

  288. void BeepOpen(void)
    

  289. {
    

  290. P3_4=0;  
    

  291. }
    


  292. 

  293. void BeepClose(void)
    

  294. {
    

  295. P3_4=1;  
    

  296. }
    


  297. 

  298. void VoiceScan(void)
    

  299. {
    


  300. 

  301.           static unsigned char Su8Lock=0;  
    


  302. 

  303. if(1==vGu8BeepTimerFlag&&vGu16BeepTimerCnt>0)
    

  304.           {
    

  305.                   if(0==Su8Lock)
    

  306.                   {
    

  307.                    Su8Lock=1;  
    

  308. BeepOpen(); 
    

  309.      }
    

  310.     else  
    

  311. {     
    


  312. 

  313.                        vGu16BeepTimerCnt--;         
    


  314. 

  315.                    if(0==vGu16BeepTimerCnt)
    

  316.                    {
    

  317.                            Su8Lock=0;     
    

  318. BeepClose();  
    

  319.                    }
    


  320. 

  321. }
    

  322.           }         
    

  323. }


本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏269 举报

一路向北lm 发表于 2017-12-7 11:54 | 显示全部楼层
**分享
回复

收藏269 举报

赵成玉1 发表于 2017-12-8 08:22 | 显示全部楼层
先赞一下再说
回复

收藏269 举报

as791026747 发表于 2017-12-8 15:57 | 显示全部楼层
厉害厉害
回复

收藏269 举报

家长不监护 发表于 2017-12-9 14:00 | 显示全部楼层
embassy 发表于 2016-10-8 13:59
很简单的 c语言, 被你用的多么多么牛叉的样子.  大部分在工作中根本不需要这么复杂,      c语言本身就是很 ...

对您可能没帮助，但是对别人也许是有帮助的。您也可以写一部集成芯片手册来，帮助大家。
回复

收藏269 举报

 楼主| jianhong_wu 发表于 2017-12-10 11:15 | 显示全部楼层
第九十九节： “行列扫描式”矩阵按键的单个触发（原始版）。

【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个按键都触发一次蜂鸣器鸣叫。
复制

  1. 

  2. #include "REG52.H"  
    


  3. 

  4. #define KEY_VOICE_TIME   50     
    


  5. 

  6. #define KEY_SHORT_TIME  20     //按键去抖动的“滤波”时间
    


  7. 

  8. void T0_time();
    

  9. void SystemInitial(void) ;
    

  10. void Delay(unsigned long u32DelayTime) ;
    

  11. void PeripheralInitial(void) ;
    


  12. 

  13. void BeepOpen(void);   
    

  14. void BeepClose(void); 
    


  15. 

  16. void VoiceScan(void);
    

  17. void KeyScan(void);    
    

  18. void KeyTask(void);   
    


  19. 

  20. sbit P3_4=P3^4;       //蜂鸣器
    


  21. 

  22. sbit ROW_INPUT1=P2^2;  //第1行输入口。
    

  23. sbit ROW_INPUT2=P2^1;  //第2行输入口。
    

  24. sbit ROW_INPUT3=P2^0;  //第3行输入口。
    


  25. 

  26. sbit COLUMN_OUTPUT1=P2^5;  //第1列输出口。
    

  27. sbit COLUMN_OUTPUT2=P2^4;  //第2列输出口。
    

  28. sbit COLUMN_OUTPUT3=P2^3;  //第3列输出口。
    


  29. 

  30. volatile unsigned char vGu8BeepTimerFlag=0;  
    

  31. volatile unsigned int vGu16BeepTimerCnt=0;  
    


  32. 


  33. 

  34. volatile unsigned char vGu8KeySec=0;  //按键的触发序号
    


  35. 

  36. void main() 
    

  37. {
    

  38. SystemInitial();            
    

  39. Delay(10000);               
    

  40. PeripheralInitial();      
    

  41.     while(1)  
    

  42. {  
    

  43.     KeyTask();       //按键的任务函数
    

  44.     }
    

  45. }
    


  46. 

  47. /* 注释一：
    

  48. *  矩阵按键扫描的详细过程：
    

  49. *  先输出某1列低电平，其它2列输出高电平，延时等待2ms后（等此3列输出同步稳定），
    

  50. *  再分别判断3行的输入IO口， 如果发现哪一行是低电平，就说明对应的某个按键被触发。
    

  51. *  依次循环切换输出的3种状态，并且分别判断输入的3行，就可以检测完9个按键。矩阵按键的
    

  52. *  去抖动处理方法跟我前面讲的独立按键去抖动方法是一样的，不再重复多讲。
    

  53. */
    


  54. 

  55. void KeyScan(void)  //此函数放在定时中断里每1ms扫描一次
    

  56. {
    

  57.    static unsigned char Su8KeyLock=0;        
    

  58.    static unsigned int  Su16KeyCnt=0;  
    

  59.    static unsigned char Su8KeyStep=1;  
    


  60. 

  61.    switch(Su8KeyStep)
    

  62.    {
    

  63.      case 1:   //按键扫描输出第一列低电平
    

  64.           COLUMN_OUTPUT1=0;      
    

  65.           COLUMN_OUTPUT2=1;
    

  66.           COLUMN_OUTPUT3=1;    
    


  67. 

  68.           Su16KeyCnt=0;  //延时计数器清零
    

  69.           Su8KeyStep++;  //切换到下一个运行步骤
    

  70.           break;
    


  71. 

  72.      case 2:     //延时等待2ms后（等此3列输出同步稳定）。不是按键的去抖动延时。
    

  73.           Su16KeyCnt++;
    

  74.           if(Su16KeyCnt>=2)
    

  75.           {
    

  76.              Su16KeyCnt=0;
    

  77.              Su8KeyStep++;     //切换到下一个运行步骤
    

  78.           }
    

  79.           break;
    


  80. 

  81.      case 3:
    

  82.           if(1==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3)
    

  83.           {  
    

  84.              Su8KeyStep++;  //如果没有按键按下，切换到下一个运行步骤
    

  85.              Su8KeyLock=0;  //按键自锁标志清零
    

  86.              Su16KeyCnt=0; //按键去抖动延时计数器清零，此行非常巧妙        
    

  87.           }
    

  88.           else if(0==Su8KeyLock)  //有按键按下，且是第一次触发
    

  89.           {
    

  90.               if(0==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3)
    

  91.               {
    

  92.                   Su16KeyCnt++;  //去抖动延时计数器
    

  93.                   if(Su16KeyCnt>=KEY_SHORT_TIME)
    

  94.                   {
    

  95.                       Su16KeyCnt=0;
    

  96.                       Su8KeyLock=1;//自锁置1,避免一直触发,只有松开按键,此标志位才会被清零
    

  97.                       vGu8KeySec=1;  //触发1号键 对应S1键
    

  98.                   }
    


  99. 

  100.               }
    

  101.               else if(1==ROW_INPUT1&&0==ROW_INPUT2&&1==ROW_INPUT3)
    

  102.               {
    

  103.                   Su16KeyCnt++;  //去抖动延时计数器
    

  104.                   if(Su16KeyCnt>=KEY_SHORT_TIME)
    

  105.                   {
    

  106.                       Su16KeyCnt=0;
    

  107.                       Su8KeyLock=1;//自锁置1,避免一直触发,只有松开按键,此标志位才会被清零
    

  108.                       vGu8KeySec=2;  //触发2号键 对应S2键
    

  109.                   }   
    

  110.               }
    

  111.               else if(1==ROW_INPUT1&&1==ROW_INPUT2&&0==ROW_INPUT3)
    

  112.               {
    

  113.                   Su16KeyCnt++;  //去抖动延时计数器
    

  114.                   if(Su16KeyCnt>=KEY_SHORT_TIME)
    

  115.                   {
    

  116.                       Su16KeyCnt=0;
    

  117.                       Su8KeyLock=1;//自锁置1,避免一直触发,只有松开按键,此标志位才会被清零
    

  118.                       vGu8KeySec=3;  //触发3号键 对应S3键
    

  119.                   }   
    

  120.               }
    


  121. 

  122.           }
    

  123.           break;
    

  124.      case 4:   //按键扫描输出第二列低电平
    

  125.           COLUMN_OUTPUT1=1;      
    

  126.           COLUMN_OUTPUT2=0;
    

  127.           COLUMN_OUTPUT3=1;    
    


  128. 

  129.           Su16KeyCnt=0;  //延时计数器清零
    

  130.           Su8KeyStep++;  //切换到下一个运行步骤
    

  131.           break;
    


  132. 

  133.      case 5:     //延时等待2ms后（等此3列输出同步稳定）。不是按键的去抖动延时。
    

  134.           Su16KeyCnt++;
    

  135.           if(Su16KeyCnt>=2)
    

  136.           {
    

  137.              Su16KeyCnt=0;
    

  138.              Su8KeyStep++;     //切换到下一个运行步骤
    

  139.           }
    

  140.           break;
    


  141. 

  142.      case 6:
    

  143.           if(1==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3)
    

  144.           {  
    

  145.              Su8KeyStep++;  //如果没有按键按下，切换到下一个运行步骤
    

  146.              Su8KeyLock=0;  //按键自锁标志清零
    

  147.              Su16KeyCnt=0; //按键去抖动延时计数器清零，此行非常巧妙        
    

  148.           }
    

  149.           else if(0==Su8KeyLock)  //有按键按下，且是第一次触发
    

  150.           {
    

  151.               if(0==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3)
    

  152.               {
    

  153.                   Su16KeyCnt++;  //去抖动延时计数器
    

  154.                   if(Su16KeyCnt>=KEY_SHORT_TIME)
    

  155.                   {
    

  156.                       Su16KeyCnt=0;
    

  157.                       Su8KeyLock=1;//自锁置1,避免一直触发,只有松开按键,此标志位才会被清零
    

  158.                       vGu8KeySec=4;  //触发4号键 对应S4键
    

  159.                   }
    


  160. 

  161.               }
    

  162.               else if(1==ROW_INPUT1&&0==ROW_INPUT2&&1==ROW_INPUT3)
    

  163.               {
    

  164.                   Su16KeyCnt++;  //去抖动延时计数器
    

  165.                   if(Su16KeyCnt>=KEY_SHORT_TIME)
    

  166.                   {
    

  167.                       Su16KeyCnt=0;
    

  168.                       Su8KeyLock=1;//自锁置1,避免一直触发,只有松开按键,此标志位才会被清零
    

  169.                       vGu8KeySec=5;  //触发5号键 对应S5键
    

  170.                   }   
    

  171.               }
    

  172.               else if(1==ROW_INPUT1&&1==ROW_INPUT2&&0==ROW_INPUT3)
    

  173.               {
    

  174.                   Su16KeyCnt++;  //去抖动延时计数器
    

  175.                   if(Su16KeyCnt>=KEY_SHORT_TIME)
    

  176.                   {
    

  177.                       Su16KeyCnt=0;
    

  178.                       Su8KeyLock=1;//自锁置1,避免一直触发,只有松开按键,此标志位才会被清零
    

  179.                       vGu8KeySec=6;  //触发6号键 对应S6键
    

  180.                   }   
    

  181.               }
    


  182. 

  183.           }
    

  184.           break;
    

  185.      case 7:   //按键扫描输出第三列低电平
    

  186.           COLUMN_OUTPUT1=1;      
    

  187.           COLUMN_OUTPUT2=1;
    

  188.           COLUMN_OUTPUT3=0;    
    


  189. 

  190.           Su16KeyCnt=0;  //延时计数器清零
    

  191.           Su8KeyStep++;  //切换到下一个运行步骤
    

  192.           break;
    


  193. 

  194.      case 8:     //延时等待2ms后（等此3列输出同步稳定）。不是按键的去抖动延时。
    

  195.           Su16KeyCnt++;
    

  196.           if(Su16KeyCnt>=2)
    

  197.           {
    

  198.              Su16KeyCnt=0;
    

  199.              Su8KeyStep++;     //切换到下一个运行步骤
    

  200.           }
    

  201.           break;
    


  202. 

  203.      case 9:
    

  204.           if(1==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3)
    

  205.           {  
    

  206.              Su8KeyStep=1;  //如果没有按键按下，返回到第一步，重新开始扫描！！！！！！
    

  207.              Su8KeyLock=0;  //按键自锁标志清零
    

  208.              Su16KeyCnt=0; //按键去抖动延时计数器清零，此行非常巧妙        
    

  209.           }
    

  210.           else if(0==Su8KeyLock)  //有按键按下，且是第一次触发
    

  211.           {
    

  212.               if(0==ROW_INPUT1&&1==ROW_INPUT2&&1==ROW_INPUT3)
    

  213.               {
    

  214.                   Su16KeyCnt++;  //去抖动延时计数器
    

  215.                   if(Su16KeyCnt>=KEY_SHORT_TIME)
    

  216.                   {
    

  217.                       Su16KeyCnt=0;
    

  218.                       Su8KeyLock=1;//自锁置1,避免一直触发,只有松开按键,此标志位才会被清零
    

  219.                       vGu8KeySec=7;  //触发7号键 对应S7键
    

  220.                   }
    


  221. 

  222.               }
    

  223.               else if(1==ROW_INPUT1&&0==ROW_INPUT2&&1==ROW_INPUT3)
    

  224.               {
    

  225.                   Su16KeyCnt++;  //去抖动延时计数器
    

  226.                   if(Su16KeyCnt>=KEY_SHORT_TIME)
    

  227.                   {
    

  228.                       Su16KeyCnt=0;
    

  229.                       Su8KeyLock=1;//自锁置1,避免一直触发,只有松开按键,此标志位才会被清零
    

  230.                       vGu8KeySec=8;  //触发8号键 对应S8键
    

  231.                   }   
    

  232.               }
    

  233.               else if(1==ROW_INPUT1&&1==ROW_INPUT2&&0==ROW_INPUT3)
    

  234.               {
    

  235.                   Su16KeyCnt++;  //去抖动延时计数器
    

  236.                   if(Su16KeyCnt>=KEY_SHORT_TIME)
    

  237.                   {
    

  238.                       Su16KeyCnt=0;
    

  239.                       Su8KeyLock=1;//自锁置1,避免一直触发,只有松开按键,此标志位才会被清零
    

  240.                       vGu8KeySec=9;  //触发9号键 对应S9键
    

  241.                   }   
    

  242.               }
    


  243. 

  244.           }
    

  245.           break;
    

  246.    }
    


  247. 

  248. }
    


  249. 

  250. void KeyTask(void)    //按键任务函数，放在主函数内
    

  251. {
    

  252. if(0==vGu8KeySec)
    

  253. {
    

  254. return; //按键的触发序号是0意味着无按键触发，直接退出当前函数，不执行此函数下面的代码
    

  255. }
    


  256. 

  257. switch(vGu8KeySec) //根据不同的按键触发序号执行对应的代码
    

  258. {
    

  259.    case 1:     //S1触发的任务
    


  260. 

  261.             vGu8BeepTimerFlag=0;  
    

  262. vGu16BeepTimerCnt=KEY_VOICE_TIME;  //发出“嘀”一声
    

  263.             vGu8BeepTimerFlag=1;  
    


  264. 

  265. vGu8KeySec=0;  //响应按键服务处理程序后，按键编号必须清零，避免一直触发
    

  266. break;
    


  267. 

  268.    case 2:     //S2触发的任务
    


  269. 

  270.             vGu8BeepTimerFlag=0;  
    

  271. vGu16BeepTimerCnt=KEY_VOICE_TIME;  //发出“嘀”一声
    

  272.             vGu8BeepTimerFlag=1;  
    


  273. 

  274. vGu8KeySec=0;  //响应按键服务处理程序后，按键编号必须清零，避免一直触发
    

  275. break;
    


  276. 

  277.    case 3:     //S3触发的任务
    


  278. 

  279.             vGu8BeepTimerFlag=0;  
    

  280. vGu16BeepTimerCnt=KEY_VOICE_TIME;  //发出“嘀”一声
    

  281.             vGu8BeepTimerFlag=1;  
    


  282. 

  283. vGu8KeySec=0;  //响应按键服务处理程序后，按键编号必须清零，避免一直触发
    

  284. break;
    


  285. 

  286.    case 4:     //S4触发的任务
    


  287. 

  288.             vGu8BeepTimerFlag=0;  
    

  289. vGu16BeepTimerCnt=KEY_VOICE_TIME;  //发出“嘀”一声
    

  290.             vGu8BeepTimerFlag=1;  
    


  291. 

  292. vGu8KeySec=0;  //响应按键服务处理程序后，按键编号必须清零，避免一直触发
    

  293. break;
    


  294. 

  295.    case 5:     //S5触发的任务
    


  296. 

  297.             vGu8BeepTimerFlag=0;  
    

  298. vGu16BeepTimerCnt=KEY_VOICE_TIME;  //发出“嘀”一声
    

  299.             vGu8BeepTimerFlag=1;  
    


  300. 

  301. vGu8KeySec=0;  //响应按键服务处理程序后，按键编号必须清零，避免一直触发
    

  302. break;
    


  303. 

  304.    case 6:     //S6触发的任务
    


  305. 

  306.             vGu8BeepTimerFlag=0;  
    

  307. vGu16BeepTimerCnt=KEY_VOICE_TIME;  //发出“嘀”一声
    

  308.             vGu8BeepTimerFlag=1;  
    


  309. 

  310. vGu8KeySec=0;  //响应按键服务处理程序后，按键编号必须清零，避免一直触发
    

  311. break;
    


  312. 

  313.    case 7:     //S7触发的任务
    


  314. 

  315.             vGu8BeepTimerFlag=0;  
    

  316. vGu16BeepTimerCnt=KEY_VOICE_TIME;  //发出“嘀”一声
    

  317.             vGu8BeepTimerFlag=1;  
    


  318. 

  319. vGu8KeySec=0;  //响应按键服务处理程序后，按键编号必须清零，避免一直触发
    

  320. break;
    


  321. 

  322.    case 8:     //S8触发的任务
    


  323. 

  324.             vGu8BeepTimerFlag=0;  
    

  325. vGu16BeepTimerCnt=KEY_VOICE_TIME;  //发出“嘀”一声
    

  326.             vGu8BeepTimerFlag=1;  
    


  327. 

  328. vGu8KeySec=0;  //响应按键服务处理程序后，按键编号必须清零，避免一直触发
    

  329. break;
    


  330. 

  331.    case 9:     //S9触发的任务
    


  332. 

  333.             vGu8BeepTimerFlag=0;  
    

  334. vGu16BeepTimerCnt=KEY_VOICE_TIME;  //发出“嘀”一声
    

  335.             vGu8BeepTimerFlag=1;  
    


  336. 

  337. vGu8KeySec=0;  //响应按键服务处理程序后，按键编号必须清零，避免一直触发
    

  338. break;
    


  339. 

  340. }
    

  341. }
    


  342. 


  343. 


  344. 

  345. void T0_time() interrupt 1     
    

  346. {
    

  347. VoiceScan();  
    

  348. KeyScan();    //按键识别的驱动函数
    


  349. 

  350. TH0=0xfc;   
    

  351. TL0=0x66;   
    

  352. }
    


  353. 


  354. 

  355. void SystemInitial(void) 
    

  356. {
    

  357. TMOD=0x01;  
    

  358. TH0=0xfc;   
    

  359. TL0=0x66;   
    

  360. EA=1;       
    

  361. ET0=1;      
    

  362. TR0=1;      
    

  363. }
    


  364. 

  365. void Delay(unsigned long u32DelayTime) 
    

  366. {
    

  367.     for(;u32DelayTime>0;u32DelayTime--); 
    

  368. }
    


  369. 

  370. void PeripheralInitial(void) 
    

  371. {
    


  372. 

  373. }
    


  374. 

  375. void BeepOpen(void)
    

  376. {
    

  377. P3_4=0;  
    

  378. }
    


  379. 

  380. void BeepClose(void)
    

  381. {
    

  382. P3_4=1;  
    

  383. }
    


  384. 

  385. void VoiceScan(void)
    

  386. {
    


  387. 

  388.           static unsigned char Su8Lock=0;  
    


  389. 

  390. if(1==vGu8BeepTimerFlag&&vGu16BeepTimerCnt>0)
    

  391.           {
    

  392.                   if(0==Su8Lock)
    

  393.                   {
    

  394.                    Su8Lock=1;  
    

  395. BeepOpen(); 
    

  396.      }
    

  397.     else  
    

  398. {     
    


  399. 

  400.                        vGu16BeepTimerCnt--;         
    


  401. 

  402.                    if(0==vGu16BeepTimerCnt)
    

  403.                    {
    

  404.                            Su8Lock=0;     
    

  405. BeepClose();  
    

  406.                    }
    


  407. 

  408. }
    

  409.           }         
    

  410. }


本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏269 举报

ifxz0123 发表于 2017-12-11 09:11 | 显示全部楼层
好贴，必须支持下
回复

收藏269 举报

avensun 发表于 2017-12-11 21:33 | 显示全部楼层
深入浅出，讲的真好！
回复

收藏269 举报

Dalarl2008 发表于 2017-12-11 22:07 | 显示全部楼层
回复

收藏269 举报

Dalarl2008 发表于 2017-12-11 22:07 | 显示全部楼层
谢谢 下载完毕
回复

收藏269 举报

李劲均 发表于 2017-12-13 11:49 | 显示全部楼层
谢谢吴老师，你的无私奉献，造就了你的功德无量。
回复

收藏269 举报

李劲均 发表于 2017-12-15 13:58 | 显示全部楼层
谢谢分享
回复

收藏269 举报

laosun9911 发表于 2017-12-16 14:27 | 显示全部楼层
楼主以前是不是在**论坛？
现在来21IC了？
那个控制欲极强的**有时候确实不可理喻。
回复

收藏269 举报

下一页 »
1 ...131415161718192021... 34下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

快速回复 在线客服 返回列表 返回顶部