83736|194

98

帖子

0

TA的资源

一粒金砂(高级)

从业将近十年!手把手教你单片机程序框架(连载) [复制链接]

 
本帖最后由 jianhong_wu 于 2014-6-10 02:36 编辑

      大家好,我叫吴坚鸿,从事单片机开发行业将近十年,这些年一直在外面接单片机项目开发,现在借电子工程世界这个平台把我这些年的经验都分享出来。我打算每个星期写一两节,直到我江郎才尽为止,目前在其它论坛已经更新到50节的内容了,但是初步估计,我这个帖子后续不会低于100节内容,因为我要整理和分享的技术资料实在是太多了。
       第一次在这里发技术帖,希望各位版主和管理员多多包涵,如果发现我不对的地方请及时告诉我,我会马上改正,也可以直接帮我更改不对的地方。有不同见解的欢迎提出来交流,意见不同的请心平气和地交流,君子和而不同,不要太较真。
第一节:吴坚鸿谈初学单片机的误区。

第二节:delay()延时实现LED灯的闪烁。

第三节:累计主循环次数使LED灯闪烁。

第四节:累计定时中断次数使LED灯闪烁。

第五节:蜂鸣器的驱动程序。

第六节:在主函数中利用累计主循环次数来实现独立按键的检测。

第七节:在主函数中利用累计定时中断的次数来实现独立按键的检测。

第八节:在定时中断函数里执行独立按键的扫描程序。

第九节:独立按键的双击按键触发。

第十节:两个独立按键的组合按键触发。

第十一节:同一个按键短按与长按的区别触发。

第十二节:按住一个独立按键不松手的连续步进触发。

第十三节:按住一个独立按键不松手的加速匀速触发。

第十四节:矩阵键盘的单个触发。

第十五节:矩阵键盘单个触发的压缩代码编程。

第十六节:矩阵键盘的组合按键触发。

第十七节:两片联级74HC595驱动16个LED灯的基本驱动程序。

第十八节:把74HC595驱动程序翻译成类似单片机IO口直接驱动的方式。

第十九节:依次逐个点亮LED之后,再依次逐个熄灭LED的跑马灯程序。

第二十节:依次逐个亮灯并且每次只能亮一个灯的跑马灯程序。

第二十一节:多任务并行处理两路跑马灯。

第二十二节:独立按键控制跑马灯的方向。

第二十三节:独立按键控制跑马灯的速度。

第二十四节:独立按键控制跑马灯的启动和暂停。

第二十五节:用LED灯和按键来模拟工业自动化设备的运动控制。

第二十六节:在主函数while循环中驱动数码管的动态扫描程序。

第二十七节:在定时中断里动态扫描数码管的程序。

第二十八节:数码管通过切换窗口来设置参数。

第二十九节:数码管通过切换窗口来设置参数,并且不显示为0的高位。

第三十节:数码管通过闪烁来设置数据。

第三十一节:数码管通过一二级菜单来设置数据的综合程序。

第三十二节:数码管中的倒计时程序。

第三十三节:能设置速度档位的数码管倒计时程序。

第三十四节:在数码管中实现iphone4S开机密码锁的程序。

第三十五节:带数码管显示的象棋比赛专用计时器。

第三十六节:带数码管显示的加法简易计算器。

第三十七节:数码管作为仪表盘显示跑马灯的方向,速度和运行状态。

第三十八节:判断数据尾来接收一串数据的串口通用程序框架。

第三十九节:判断数据头来接收一串数据的串口通用程序框架。

第四十节:常用的自定义串口通讯协议。

第四十一节:在串口接收中断里即时解析数据头的特殊程序框架。

第四十二节:通过串口用delay延时方式发送一串数据。

第四十三节:通过串口用计数延时方式发送一串数据。

第四十四节:从机的串口收发综合程序框架

第四十五节:主机的串口收发综合程序框架

第四十六节:利用AT24C02进行掉电后的数据保存。

第四十七节:操作AT24C02时,利用“一气呵成的定时器延时”改善数码管的闪烁现象。

第四十八节:利用DS1302做一个实时时钟  。

第四十九节:利用DS18B20做一个温控器  。

第五十节:利用ADC0832采集电压信号,用平均法和区间法进行软件滤波处理。




此帖出自51单片机论坛

最新回复

上一节鸿哥列出了初学者七大误区,到底什么才是初学者关注的核心?那就是裸机奔跑的程序结构。一个好的程序结构,本身就是一个微型的多任务操作系统。   详情 回复 发表于 2024-7-4 14:01

赞赏

5

查看全部赞赏


回复
举报

98

帖子

0

TA的资源

一粒金砂(高级)

第二节:delay()延时实现LED灯的闪烁。

开场白:
    上一节鸿哥列出了初学者七大误区,到底什么才是初学者关注的核心?那就是裸机奔跑的程序结构。一个好的程序结构,本身就是一个微型的多任务操作系统。鸿哥教给大家的就是如何编写这个简单的操作系统。在main函数循环中用switch语句实现多任务并行处理的任务切换,再外加一个定时器中断,这两者的结合就是鸿哥多年来所有实战项目的核心。鸿哥的程序结构看似简单,实际上就是那么简单。大家不用着急,本篇连载文章现在才正式开始,这一节我要教会大家两个知识点:
第一点:鸿哥首次提出的“三区一线”理论。此理论把程序代码分成三个区,一个延时分割线。
第二点:delay()延时的用途。

(1)硬件平台:基于朱兆祺51单片机学习板。

(2)实现功能:让一个LED闪烁。

(3)源代码讲解如下:
  1. #include "REG52.H"

  2. void initial_myself();   
  3. void initial_peripheral();

  4. void delay_short(unsigned int uiDelayshort);
  5. void delay_long(unsigned int uiDelaylong);
  6. void led_flicker();

  7. /* 注释一:
  8. * 吴坚鸿个人的命名风格:凡是输出后缀都是_dr,凡是输入后缀都是_sr。
  9. * dr代表drive驱动,sr代表sensor感应器
  10. */
  11. sbit led_dr=P3^5;  

  12. void main()  //学习要点:深刻理解鸿哥首次提出的三区一线理论
  13.   {
  14. /* 注释二:
  15. * initial_myself()函数属于鸿哥三区一线理论的第一区,
  16. * 专门用来初始化单片机自己的寄存器以及个别外围要求响应速度快的输出设备,
  17. * 防止刚上电之后,由于输出IO口电平状态不确定而导致外围设备误动作,
  18. * 比如继电器的误动作等等。
  19. */
  20.    initial_myself();

  21. /* 注释三:
  22. * 此处的delay_long()延时函数属于第一区与第二区的分割线,
  23. * 延时时间一般是0.3秒到2秒之间,等待外围芯片和模块上电稳定。
  24. * 比如液晶模块,AT24C02存储芯片,DS1302时钟芯片,
  25. * 这类芯片有个特点,一般都是跟单片机进行串口或并口通讯的,
  26. * 并且不要求上电立即处理的。
  27. */
  28.    delay_long(100);

  29. /* 注释四:
  30. * initial_peripheral()函数属于鸿哥三区一线理论的第二区,
  31. * 专门用来初始化不要求上电立即处理的外围芯片和模块.
  32. * 比如液晶模块,AT24C02存储芯片,DS1302时钟芯片。
  33. * 本程序基于朱兆祺51单片机学习板。
  34. */
  35.    initial_peripheral();

  36. /* 注释五:
  37. * while(1){}主函数循环区属于鸿哥三区一线理论的第三区,
  38. * 专门用来编写被循环扫描到的非中断应用程序
  39. */
  40.    while(1)
  41.    {
  42.       led_flicker();   //LED闪烁应用程序
  43.    }

  44. }

  45. void led_flicker() //LED闪烁应用程序
  46. {
  47.   led_dr=1;  //LED亮
  48.   delay_short(50000);  //延时50000个空指令的时间

  49. /* 注释六:
  50. * delay_long(100)延时50000个空指令的时间,因为内嵌了一个500次的for循环
  51. */
  52.   led_dr=0;  //LED灭
  53.   delay_long(100);    //延时50000个空指令的时间  
  54. }


  55. /* 注释七:
  56. * delay_short(unsigned int uiDelayShort)是小延时函数,
  57. * 专门用在时序驱动的小延时,一般uiDelayShort的数值取10左右,
  58. * 最大一般也不超过100.本例为了解释此函数的特点,取值范围超过100。
  59. * 此函数的特点是时间的细分度高,延时时间不宜过长。uiDelayShort数值
  60. * 的大小就代表里面执行了多少条空指令的时间。数值越大,延时越长。
  61. * 时间精度不要刻意去计算,感觉差不多就行。
  62. */
  63. void delay_short(unsigned int uiDelayShort)
  64. {
  65.    unsigned int i;  
  66.    for(i=0;i<uiDelayShort;i++)
  67.    {
  68.      ;   //一个分号相当于执行一条空语句
  69.    }
  70. }


  71. /* 注释八:
  72. * delay_long(unsigned int uiDelayLong)是大延时函数,
  73. * 专门用在上电初始化的大延时,
  74. * 此函数的特点是能实现比较长时间的延时,细分度取决于内嵌for循环的次数,
  75. * uiDelayLong的数值的大小就代表里面执行了多少次500条空指令的时间。
  76. * 数值越大,延时越长。时间精度不要刻意去计算,感觉差不多就行。
  77. */
  78. void delay_long(unsigned int uiDelayLong)
  79. {
  80.    unsigned int i;
  81.    unsigned int j;
  82.    for(i=0;i<uiDelayLong;i++)
  83.    {
  84.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  85.           {
  86.              ; //一个分号相当于执行一条空语句
  87.           }
  88.    }
  89. }



  90. void initial_myself()  //初始化单片机
  91. {
  92.   led_dr=0;  //LED灭
  93. }
  94. void initial_peripheral() //初始化外围
  95. {
  96.   ;   //本例为空
  97. }
复制代码

总结陈词:
鸿哥首次提出的“三区一线”理论概况了各种项目程序的基本分区。我后续的程序就按此分区编写。
Delay()函数的长延时适用在上电初始化。
Delay()函数的短延时适用在驱动时序的脉冲延时,此时的时间不能太长,本例中暂时没有列出这方面的例子,在后面的章节中会提到。
在本例源代码中,在led_flicker()闪烁应用程序里用到的两个延时delay,它们的延时时间都太长了,在实战项目中肯定不能用这种延时,因为消耗的时间太长了,其它任务根本没有机会执行。那怎么办呢?我们应该如何改善?欲知详情,请听下回分解-----累计主循环次数使LED灯闪烁。

(未完待续,下节更精彩,不要走开哦)
此帖出自51单片机论坛

赞赏

1

查看全部赞赏


回复

98

帖子

0

TA的资源

一粒金砂(高级)

第八节:在定时中断函数里执行独立按键的扫描程序。

开场白:
上一节讲了在主函数中利用累计定时中断的次数来实现独立按键的检测,但是如果在某些项目中,需要在主函数里间歇性地执行一些一气呵成的耗时任务,当主函数正在处理一气呵成的耗时任务时(前提是没有关闭定时器中断),这个时候如果有按键按下来,就有可能没有及时被响应到而遗漏了。在定时中断函数里处理独立按键的扫描程序,可以避免这个问题。要教会大家一个知识点:如何在上一节的基础上,略作修改,就可以在定时中断函数里处理独立按键的扫描程序。

具体内容,请看源代码讲解。

(1)硬件平台:基于朱兆祺51单片机学习板。用矩阵键盘中的S1和S5号键作为独立按键,记得把输出线P0.4一直输出低电平,模拟独立按键的触发地GND。

(2)实现功能:有两个独立按键,每按一个独立按键,蜂鸣器发出“滴”的一声后就停。

(3)源代码讲解如下:
  1. #include "REG52.H"

  2. #define const_voice_short  40   //蜂鸣器短叫的持续时间


  3. /* 注释一:
  4. * 调整抖动时间阀值的大小,可以更改按键的触发灵敏度。
  5. * 去抖动的时间本质上等于累计定时中断次数的时间。
  6. */
  7. #define const_key_time1  20    //按键去抖动延时的时间
  8. #define const_key_time2  20    //按键去抖动延时的时间

  9. void initial_myself();   
  10. void initial_peripheral();
  11. void delay_long(unsigned int uiDelaylong);
  12. void T0_time();  //定时中断函数
  13. void key_service(); //按键服务的应用程序
  14. void key_scan(); //按键扫描函数 放在定时中断里

  15. sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
  16. sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键
  17. sbit key_gnd_dr=P0^4; //模拟独立按键的地GND,因此必须一直输出低电平

  18. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口

  19. unsigned char ucKeySec=0;   //被触发的按键编号

  20. unsigned int  uiKeyTimeCnt1=0; //按键去抖动延时计数器
  21. unsigned char ucKeyLock1=0; //按键触发后自锁的变量标志


  22. unsigned int  uiKeyTimeCnt2=0; //按键去抖动延时计数器
  23. unsigned char ucKeyLock2=0; //按键触发后自锁的变量标志

  24. unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器

  25. void main()
  26.   {
  27.    initial_myself();  
  28.    delay_long(100);   
  29.    initial_peripheral();
  30.    while(1)  
  31.    {
  32.        key_service(); //按键服务的应用程序
  33.    }

  34. }

  35. void key_scan()//按键扫描函数 放在定时中断里
  36. {  
  37. /* 注释二:
  38. * 独立按键扫描的详细过程:
  39. * 第一步:平时没有按键被触发时,按键的自锁标志,去抖动延时计数器一直被清零。
  40. * 第二步:一旦有按键被按下,去抖动延时计数器开始在定时中断函数里累加,在还没累加到
  41. *         阀值const_key_time1时,如果在这期间由于受外界干扰或者按键抖动,而使
  42. *         IO口突然瞬间触发成高电平,这个时候马上把延时计数器uiKeyTimeCnt1
  43. *         清零了,这个过程非常巧妙,非常有效地去除瞬间的杂波干扰。这是我实战中摸索出来的。
  44. *         以后凡是用到开关感应器的时候,都可以用类似这样的方法去干扰。
  45. * 第三步:如果按键按下的时间超过了阀值const_key_time1,则触发按键,把编号ucKeySec赋值。
  46. *         同时,马上把自锁标志ucKeyLock1置位,防止按住按键不松手后一直触发。
  47. * 第四步:等按键松开后,自锁标志ucKeyLock1及时清零,为下一次自锁做准备。
  48. * 第五步:以上整个过程,就是识别按键IO口下降沿触发的过程。
  49. */
  50.   if(key_sr1==1)//IO是高电平,说明按键没有被按下,这时要及时清零一些标志位
  51.   {
  52.      ucKeyLock1=0; //按键自锁标志清零
  53.          uiKeyTimeCnt1=0;//按键去抖动延时计数器清零,此行非常巧妙,是我实战中摸索出来的。      
  54.   }
  55.   else if(ucKeyLock1==0)//有按键按下,且是第一次被按下
  56.   {
  57.      uiKeyTimeCnt1++; //累加定时中断次数
  58.      if(uiKeyTimeCnt1>const_key_time1)
  59.      {
  60.         uiKeyTimeCnt1=0;
  61.         ucKeyLock1=1;  //自锁按键置位,避免一直触发
  62.         ucKeySec=1;    //触发1号键
  63.      }
  64.   }

  65.   if(key_sr2==1)
  66.   {
  67.      ucKeyLock2=0;
  68.          uiKeyTimeCnt2=0;
  69.   }
  70.   else if(ucKeyLock2==0)
  71.   {
  72.      uiKeyTimeCnt2++; //累加定时中断次数
  73.      if(uiKeyTimeCnt2>const_key_time2)
  74.      {
  75.         uiKeyTimeCnt2=0;
  76.         ucKeyLock2=1;
  77.         ucKeySec=2;     //触发2号键
  78.      }
  79.   }

  80. }


  81. void key_service() //第三区 按键服务的应用程序
  82. {
  83.   switch(ucKeySec) //按键服务状态切换
  84.   {
  85.     case 1:// 1号键 对应朱兆祺学习板的S1键

  86.               uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  87.               ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  88.           break;        
  89.     case 2:// 2号键 对应朱兆祺学习板的S5键

  90.               uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  91.               ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  92.           break;                    
  93.   }               
  94. }



  95. void T0_time() interrupt 1
  96. {
  97.   TF0=0;  //清除中断标志
  98.   TR0=0; //关中断

  99.   key_scan(); //按键扫描函数

  100.   if(uiVoiceCnt!=0)
  101.   {
  102.      uiVoiceCnt--; //每次进入定时中断都自减1,直到等于零为止。才停止鸣叫
  103.          beep_dr=0;  //蜂鸣器是PNP三极管控制,低电平就开始鸣叫。
  104.   }
  105.   else
  106.   {
  107.      ; //此处多加一个空指令,想维持跟if括号语句的数量对称,都是两条指令。不加也可以。
  108.            beep_dr=1;  //蜂鸣器是PNP三极管控制,高电平就停止鸣叫。
  109.   }


  110.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  111.   TL0=0x2f;
  112.   TR0=1;  //开中断
  113. }


  114. void delay_long(unsigned int uiDelayLong)
  115. {
  116.    unsigned int i;
  117.    unsigned int j;
  118.    for(i=0;i<uiDelayLong;i++)
  119.    {
  120.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  121.           {
  122.              ; //一个分号相当于执行一条空语句
  123.           }
  124.    }
  125. }


  126. void initial_myself()  //第一区 初始化单片机
  127. {
  128. /* 注释三:
  129. * 矩阵键盘也可以做独立按键,前提是把某一根公共输出线输出低电平,
  130. * 模拟独立按键的触发地,本程序中,把key_gnd_dr输出低电平。
  131. * 朱兆祺51学习板的S1和S5两个按键就是本程序中用到的两个独立按键。
  132. */
  133.   key_gnd_dr=0; //模拟独立按键的地GND,因此必须一直输出低电平


  134.   beep_dr=1; //用PNP三极管控制蜂鸣器,输出高电平时不叫。


  135.   TMOD=0x01;  //设置定时器0为工作方式1


  136.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  137.   TL0=0x2f;

  138. }
  139. void initial_peripheral() //第二区 初始化外围
  140. {
  141.   EA=1;     //开总中断
  142.   ET0=1;    //允许定时中断
  143.   TR0=1;    //启动定时中断

  144. }
复制代码

总结陈词:
本节程序已经展示了在定时中断函数里执行独立按键的扫描程序。这节和前面两节所讲的扫描方式,我都在项目上用过,具体跟项目的侧重点不同来选择不同的方式,我本人用得最多的就是当前这种方式。假如要独立按键实现类似鼠标的双击功能,我们改怎么写程序?欲知详情,请听下回分解-----独立按键的双击按键触发。

(未完待续,下节更精彩,不要走开哦)
此帖出自51单片机论坛

回复

98

帖子

0

TA的资源

一粒金砂(高级)

第六节:在主函数中利用累计主循环次数来实现独立按键的检测。

开场白:
上一节讲了多任务中蜂鸣器驱动程序的框架,这节继续利用多任务处理的方式,在主函数中利用累计主循环次数来实现独立按键的检测。要教会大家四个知识点:
第一点:独立按键的驱动程序框架。
第二点:用累计主循环次数来实现去抖动的延时。
第三点:灵活运用防止按键不松手后一直触发的按键自锁标志。
第四点:在按键去抖动延时计时中,添加一个抗干扰的软件监控判断。一旦发现瞬间杂波干扰,马上把延时计数器清零。这种方法是我在复杂的工控项目中总结出来的。以后凡是用到开关感应器的地方,都可以用类似的方法实现软件上的抗干扰处理。

具体内容,请看源代码讲解。

(1)硬件平台:基于朱兆祺51单片机学习板。用矩阵键盘中的S1和S5号键作为独立按键,记得把输出线P0.4一直输出低电平,模拟独立按键的触发地GND。

(2)实现功能:有两个独立按键,每按一个独立按键,蜂鸣器发出“滴”的一声后就停。

(3)源代码讲解如下:
  1. #include "REG52.H"

  2. #define const_voice_short  40   //蜂鸣器短叫的持续时间


  3. /* 注释一:
  4. * 调整抖动时间阀值的大小,可以更改按键的触发灵敏度。
  5. * 去抖动的时间本质上等于累计主循环次数的时间。
  6. */
  7. #define const_key_time1  500    //按键去抖动延时的时间
  8. #define const_key_time2  500    //按键去抖动延时的时间

  9. void initial_myself();   
  10. void initial_peripheral();
  11. void delay_long(unsigned int uiDelaylong);
  12. void T0_time();  //定时中断函数
  13. void key_service(); //按键服务的应用程序
  14. void key_scan(); //按键扫描函数

  15. sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
  16. sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键
  17. sbit key_gnd_dr=P0^4; //模拟独立按键的地GND,因此必须一直输出低电平

  18. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口

  19. unsigned char ucKeySec=0;   //被触发的按键编号

  20. unsigned int  uiKeyTimeCnt1=0; //按键去抖动延时计数器
  21. unsigned char ucKeyLock1=0; //按键触发后自锁的变量标志

  22. unsigned int  uiKeyTimeCnt2=0; //按键去抖动延时计数器
  23. unsigned char ucKeyLock2=0; //按键触发后自锁的变量标志

  24. unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器

  25. void main()
  26.   {
  27.    initial_myself();  
  28.    delay_long(100);   
  29.    initial_peripheral();
  30.    while(1)  
  31.    {
  32.        key_scan(); //按键扫描函数
  33.        key_service(); //按键服务的应用程序
  34.    }

  35. }

  36. void key_scan()//按键扫描函数
  37. {  
  38. /* 注释二:
  39. * 独立按键扫描的详细过程:
  40. * 第一步:平时没有按键被触发时,按键的自锁标志和去抖动延时计数器一直被清零。
  41. * 第二步:一旦有按键被按下,去抖动延时计数器开始累加,在还没累加到
  42. *         阀值const_key_time1时,如果在这期间由于受外界干扰或者按键抖动,而使
  43. *         IO口突然瞬间触发成高电平,这个时候马上又把延时计数器uiKeyTimeCnt1
  44. *         清零了,这个过程非常巧妙,非常有效地去除瞬间的杂波干扰。这是我实战中摸索出来的。
  45. *         以后凡是用到开关感应器的时候,都可以用类似这样的方法去干扰。
  46. * 第三步:如果按键按下的时间超过了阀值const_key_time1,则触发按键,把编号ucKeySec赋值。
  47. *         同时,马上把自锁标志ucKeyLock1置位,防止按住按键不松手后一直触发。
  48. * 第四步:等按键松开后,自锁标志ucKeyLock1及时清零,为下一次自锁做准备。
  49. * 第五步:以上整个过程,就是识别按键IO口下降沿触发的过程。
  50. */
  51.   if(key_sr1==1)//IO是高电平,说明按键没有被按下,这时要及时清零一些标志位
  52.   {
  53.      ucKeyLock1=0; //按键自锁标志清零
  54.          uiKeyTimeCnt1=0;//按键去抖动延时计数器清零,此行非常巧妙,是我实战中摸索出来的。      
  55.   }
  56.   else if(ucKeyLock1==0)//有按键按下,且是第一次被按下
  57.   {
  58.      ++uiKeyTimeCnt1;  //延时计数器
  59.      if(uiKeyTimeCnt1>const_key_time1)
  60.      {
  61.         uiKeyTimeCnt1=0;
  62.         ucKeyLock1=1;  //自锁按键置位,避免一直触发
  63.         ucKeySec=1;    //触发1号键
  64.      }
  65.   }

  66.   if(key_sr2==1)
  67.   {
  68.      ucKeyLock2=0;
  69.          uiKeyTimeCnt2=0;
  70.   }
  71.   else if(ucKeyLock2==0)
  72.   {
  73.      ++uiKeyTimeCnt2;
  74.      if(uiKeyTimeCnt2>const_key_time2)
  75.      {
  76.         uiKeyTimeCnt2=0;
  77.         ucKeyLock2=1;
  78.         ucKeySec=2;     //触发2号键
  79.      }
  80.   }

  81. }


  82. void key_service() //第三区 按键服务的应用程序
  83. {
  84.   switch(ucKeySec) //按键服务状态切换
  85.   {
  86.     case 1:// 1号键 对应朱兆祺学习板的S1键

  87.               uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  88.               ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  89.           break;        
  90.     case 2:// 2号键 对应朱兆祺学习板的S5键

  91.               uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  92.               ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  93.           break;                    
  94.   }               
  95. }



  96. void T0_time() interrupt 1
  97. {
  98.   TF0=0;  //清除中断标志
  99.   TR0=0; //关中断

  100.   if(uiVoiceCnt!=0)
  101.   {
  102.      uiVoiceCnt--; //每次进入定时中断都自减1,直到等于零为止。才停止鸣叫
  103.          beep_dr=0;  //蜂鸣器是PNP三极管控制,低电平就开始鸣叫。
  104.   }
  105.   else
  106.   {
  107.      ; //此处多加一个空指令,想维持跟if括号语句的数量对称,都是两条指令。不加也可以。
  108.            beep_dr=1;  //蜂鸣器是PNP三极管控制,高电平就停止鸣叫。
  109.   }


  110.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  111.   TL0=0x2f;
  112.   TR0=1;  //开中断
  113. }


  114. void delay_long(unsigned int uiDelayLong)
  115. {
  116.    unsigned int i;
  117.    unsigned int j;
  118.    for(i=0;i<uiDelayLong;i++)
  119.    {
  120.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  121.           {
  122.              ; //一个分号相当于执行一条空语句
  123.           }
  124.    }
  125. }


  126. void initial_myself()  //第一区 初始化单片机
  127. {
  128. /* 注释三:
  129. * 矩阵键盘也可以做独立按键,前提是把某一根公共输出线输出低电平,
  130. * 模拟独立按键的触发地,本程序中,把key_gnd_dr输出低电平。
  131. * 朱兆祺51学习板的S1和S5两个按键就是本程序中用到的两个独立按键。
  132. */
  133.   key_gnd_dr=0; //模拟独立按键的地GND,因此必须一直输出低电平


  134.   beep_dr=1; //用PNP三极管控制蜂鸣器,输出高电平时不叫。


  135.   TMOD=0x01;  //设置定时器0为工作方式1


  136.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  137.   TL0=0x2f;

  138. }
  139. void initial_peripheral() //第二区 初始化外围
  140. {
  141.   EA=1;     //开总中断
  142.   ET0=1;    //允许定时中断
  143.   TR0=1;    //启动定时中断

  144. }
复制代码


总结陈词:
    本节程序已经展示了在主函数中,利用累计主循环次数来实现独立按键的检测。这种方法我经常在实战用应用,但是它也有一个小小的不足,随着在主函数循环中任务量的增加,为了保证去抖动延时的时间一致性,要适当调整一下去抖动的阀值const_key_time1。如何解决这个问题呢?欲知详情,请听下回分解-----在主函数中利用累计定时中断的次数来实现独立按键的检测。

(未完待续,下节更精彩,不要走开哦)
此帖出自51单片机论坛

回复

98

帖子

0

TA的资源

一粒金砂(高级)

本帖最后由 jianhong_wu 于 2014-7-6 21:38 编辑
嫖正欢 发表于 2014-7-6 12:34
可能我看得不是太仔细,LZ你第一节说误区的时候,我觉得这不是误区,而是你自己的一些想法。
这不能称为误 ...

每个人理解不一样,有的网友看到我的观点后会如梦初醒,茅舍顿开。也有的网友非常不赞同我的观点,所以针对这个问题我也不想反驳什么。我只想分享一下我去年年底的一个经历。有一个惠州的网友,他非常努力地自学单片机,花了很多钱买了很多学习板和书籍,都不得要领。他看到我这个文章后,他非要我教他学单片机,不惜重金。2014年的元旦假期,他过来找到我,我们第一次见面,他就拿出一本厚厚的自学笔记给我看,里面密密麻麻地记着各种寄存器的名称,以及各种概念名词,C语言的各种高级功能。我看了之后,就直接告诉他,把自学笔记都丢掉吧,学单片机不需要做笔记,就像一个球类运动一样,要的是球感,有了球感后,一切都很简单,而要获得球感,就必须多打球。想学好单片机,必须快速进入到动手编程中,而要想快速进入到编程中,就必须先把一大部分无关紧要的内容和知识暂时抛弃掉,这个无关紧要的知识和内容就是我所说的误区。比如C语言的指针,我毕业工作2年后才慢慢领悟到它有什么用,但是之前不会指针并不会影响我开发项目。再说到那个惠州的网友,他自从受到我点拨之后,目前已经入门了。

此帖出自51单片机论坛

回复

98

帖子

0

TA的资源

一粒金砂(高级)

第三节:累计主循环次数使LED灯闪烁。

开场白:
上一节鸿哥提到delay()延时函数消耗的时间太长了,其它任务根本没有机会执行,我们该怎么改善?本节教大家利用累计主循环次数的方法来解决这个问题。这一节要教会大家两个知识点:
第一点:利用累计主循环次数的方法实现时间延时
第二点:switch核心语句之初体验。 鸿哥所有的实战项目都是基于switch语句实现多任务并行处理。
(1)硬件平台:基于朱兆祺51单片机学习板。
(2)实现功能:让一个LED闪烁。
(3)源代码讲解如下:
  1. #include "REG52.H"


  2. /* 注释一:
  3. * const_time_level是统计循环次数的设定上限,数值越大,LED延时的时间越久
  4. */
  5. #define const_time_level 10000  

  6. void initial_myself();   
  7. void initial_peripheral();
  8. void delay_long(unsigned int uiDelaylong);
  9. void led_flicker();

  10. sbit led_dr=P3^5;  

  11. /* 注释二:
  12. * 吴坚鸿个人的命名风格:凡是switch语句里面的步骤变量后缀都是Step.
  13. * 前缀带uc,ui,ul分别表示此变量是unsigned char,unsigned int,unsigned long.
  14. */
  15. unsigned char ucLedStep=0; //步骤变量
  16. unsigned int  uiTimeCnt=0; //统计循环次数的延时计数器
  17. void main()
  18.   {
  19.    initial_myself();  
  20.    delay_long(100);   
  21.    initial_peripheral();
  22.    while(1)   
  23.    {
  24.       led_flicker();   
  25.    }

  26. }

  27. void led_flicker() ////第三区 LED闪烁应用程序
  28. {
  29.   
  30.   switch(ucLedStep)
  31.   {
  32.      case 0:
  33. /* 注释三:
  34. * uiTimeCnt累加循环次数,只有当它的次数大于或等于设定上限const_time_level时,
  35. * 才会去改变LED灯的状态,否则CPU退出led_flicker()任务,继续快速扫描其他的任务,
  36. * 这样的程序结构就可以达到多任务并行处理的目的。
  37. * 本程序基于朱兆祺51单片机学习板
  38. */
  39.           uiTimeCnt++;  //累加循环次数,
  40.                   if(uiTimeCnt>=const_time_level) //时间到
  41.                   {
  42.                      uiTimeCnt=0; //时间计数器清零
  43.              led_dr=1;    //让LED亮
  44.                          ucLedStep=1; //切换到下一个步骤
  45.                   }
  46.               break;
  47.      case 1:
  48.           uiTimeCnt++;  //累加循环次数,
  49.                   if(uiTimeCnt>=const_time_level) //时间到
  50.                   {
  51.                      uiTimeCnt=0; //时间计数器清零
  52.              led_dr=0;    //让LED灭
  53.                          ucLedStep=0; //返回到上一个步骤
  54.                   }
  55.               break;
  56.   
  57.   }

  58. }


  59. void delay_long(unsigned int uiDelayLong)
  60. {
  61.    unsigned int i;
  62.    unsigned int j;
  63.    for(i=0;i<uiDelayLong;i++)
  64.    {
  65.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  66.           {
  67.              ; //一个分号相当于执行一条空语句
  68.           }
  69.    }
  70. }


  71. void initial_myself()  //第一区 初始化单片机
  72. {
  73.   led_dr=0;  //LED灭
  74. }
  75. void initial_peripheral() //第二区 初始化外围
  76. {
  77.   ;   //本例为空
  78. }
复制代码

总结陈词:
    在实际项目中,用累计主循环次数实现时间延时是一个不错的选择。这种方法能胜任多任务处理的程序框架,但是它本身也有一个小小的不足。随着主函数里任务量的增加,我们为了保证延时时间的准确性,要不断修正设定上限const_time_level 。我们该怎么解决这个问题呢?欲知详情,请听下回分解-----累计定时中断次数使LED灯闪烁。

(未完待续,下节更精彩,不要走开哦)
此帖出自51单片机论坛

回复

98

帖子

0

TA的资源

一粒金砂(高级)

第八十四节:实时同步把键盘输入的BCD码数组转换成数值的液晶屏显示程序。

开场白:
    键盘直接输入的是带小数点的BCD码数组,要把它们转换成具体的数值才可以更好的在程序里运算或者处理。如何把BCD码数组实时同步转换成数值?这一节主要跟大家讲这方面的算法程序。另外,有一个地方值得注意:上一节键盘输入的小数点个数可以限制成最大2位,但是整数部分没有限制。这节为了也能限制整数部分的最大个数为3位,我修改了上一节的void set_data(…)函数。所以这节的void set_data(…)函数跟上一节的void set_data(…)函数有点不一样,需要特别注意。

具体内容,请看源代码讲解。

(1)     硬件平台:
基于朱兆祺51单片机学习板。数字1键对应S1键,数字2键对应S2键,数字3键对应S3键…. 数字9键对应S9键, 数字0键对应S10键。小数键对应S11,清零键对应S16,其它按键不用。

(2)     实现功能:
用矩阵键盘输入任意数字或小数点。小数点不能超过2位,一旦超过2位,再按其它按键则输入无效。整数部分不能超过3位,一旦超过3位,再按其它按键则输入无效。想重新输入,必须按S16清零按键才能重新输入。每次键盘输入的第一行BCD码数组会同步更新显示在第二行的数值上。
84节照片.jpg
(3)源代码讲解如下:
  1. #include "REG52.H"


  2. #define const_voice_short  40   //蜂鸣器短叫的持续时间

  3. #define const_key_time  10    //按键去抖动延时的时间

  4. sbit key_sr1=P0^0; //第一行输入
  5. sbit key_sr2=P0^1; //第二行输入
  6. sbit key_sr3=P0^2; //第三行输入
  7. sbit key_sr4=P0^3; //第四行输入

  8. sbit key_dr1=P0^4; //第一列输出
  9. sbit key_dr2=P0^5; //第二列输出
  10. sbit key_dr3=P0^6; //第三列输出
  11. sbit key_dr4=P0^7; //第四列输出

  12. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口

  13. sbit  LCDCS_dr  = P1^6;  //片选线
  14. sbit  LCDSID_dr = P1^7;  //串行数据线
  15. sbit  LCDCLK_dr = P3^2;  //串行时钟线
  16. sbit  LCDRST_dr = P3^4;  //复位线

  17. void SendByteToLcd(unsigned char ucData);  //发送一个字节数据到液晶模块
  18. void SPIWrite(unsigned char ucWData, unsigned char ucWRS); //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
  19. void WriteCommand(unsigned char ucCommand); //发送一个字节的命令给液晶模块
  20. void LCDWriteData(unsigned char ucData);   //发送一个字节的数据给液晶模块
  21. void LCDInit(void);  //初始化  函数内部包括液晶模块的复位
  22. void display_clear(unsigned char ucFillDate); // 清屏 全部显示空填充0x00   全部显示点阵用0xff
  23. void insert_buffer_to_canvas(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount);//把字模插入画布.
  24. void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount,unsigned int uiOffSetAddr); //显示任意点阵函数
  25. unsigned char *number_to_matrix(unsigned char  ucBitNumber); //把一位数字转换成字模首地址的函数
  26. void delay_short(unsigned int uiDelayshort); //延时
  27. void delay_long(unsigned int uiDelayLong);

  28. void key_number_input(unsigned char ucKeyNumber); //输入数字按键
  29. void set_data(unsigned char ucKeyNumberTemp, //设置参数
  30.               unsigned char ucDotBitMax,
  31.               unsigned char ucDataCntMax,
  32.               unsigned char *p_ucDotCnt,
  33.               unsigned char *p_ucDotBitS,
  34.                           unsigned char *p_ucWdPartCnt,
  35.                           unsigned char *p_ucSetDataBuffer,
  36.                           unsigned char ucIntCntMax,
  37.                           unsigned char *p_ucIntCnt);

  38. unsigned long buffer_to_data(unsigned char ucConverDataSize,unsigned char ucConverDotCnt,unsigned char *p_ucConverBuffer); //把带小数点的BCD数组转换成long类型的数值。

  39. void key_delete_input(void); //删除按键

  40. void T0_time(); //定时中断函数
  41. void key_service();
  42. void key_scan(); //按键扫描函数 放在定时中断里

  43. void initial_myself();   
  44. void initial_peripheral();


  45. void lcd_display_service(void); //应用层面的液晶屏显示程序
  46. void clear_all_canvas(void);  //把画布全部清零

  47. code unsigned char Zf816_0[]=
  48. {
  49. /*--  文字:  0  --*/
  50. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  51. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
  52. };

  53. code unsigned char Zf816_1[]=
  54. {
  55. /*--  文字:  1  --*/
  56. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  57. 0x00,0x00,0x00,0x10,0x70,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x7C,0x00,0x00,
  58. };

  59. code unsigned char Zf816_2[]=
  60. {
  61. /*--  文字:  2  --*/
  62. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  63. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x04,0x04,0x08,0x10,0x20,0x42,0x7E,0x00,0x00,
  64. };

  65. code unsigned char Zf816_3[]=
  66. {
  67. /*--  文字:  3  --*/
  68. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  69. 0x00,0x00,0x00,0x3C,0x42,0x42,0x04,0x18,0x04,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  70. };

  71. code unsigned char Zf816_4[]=
  72. {
  73. /*--  文字:  4  --*/
  74. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  75. 0x00,0x00,0x00,0x04,0x0C,0x14,0x24,0x24,0x44,0x44,0x7E,0x04,0x04,0x1E,0x00,0x00,
  76. };

  77. code unsigned char Zf816_5[]=
  78. {
  79. /*--  文字:  5  --*/
  80. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  81. 0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  82. };

  83. code unsigned char Zf816_6[]=
  84. {
  85. /*--  文字:  6  --*/
  86. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  87. 0x00,0x00,0x00,0x1C,0x24,0x40,0x40,0x58,0x64,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
  88. };


  89. code unsigned char Zf816_7[]=
  90. {
  91. /*--  文字:  7  --*/
  92. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  93. 0x00,0x00,0x00,0x7E,0x44,0x44,0x08,0x08,0x10,0x10,0x10,0x10,0x10,0x10,0x00,0x00,
  94. };

  95. code unsigned char Zf816_8[]=
  96. {
  97. /*--  文字:  8  --*/
  98. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  99. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x24,0x18,0x24,0x42,0x42,0x42,0x3C,0x00,0x00,
  100. };

  101. code unsigned char Zf816_9[]=
  102. {
  103. /*--  文字:  9  --*/
  104. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  105. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x26,0x1A,0x02,0x02,0x24,0x38,0x00,0x00,
  106. };


  107. code unsigned char Zf816_nc[]=  //空字模
  108. {
  109. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  110. };

  111. code unsigned char Zf816_dot[]=  //小数点
  112. {
  113. /*--  文字:  .  --*/
  114. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  115. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x60,0x60,0x00,0x00,
  116. };

  117. code unsigned char Zf816_mao_hao[]=  //冒号
  118. {
  119. /*--  文字:  :  --*/
  120. /*--  宋体12;  此字体下对应的点阵为:宽x高=8x16   --*/
  121. 0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,
  122. };

  123. code unsigned char Hz1616_yi[]=
  124. {
  125. /*--  文字:  一  --*/
  126. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  127. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x7F,0xFE,
  128. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  129. };

  130. code unsigned char Hz1616_xiang[]=
  131. {
  132. /*--  文字:  项  --*/
  133. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  134. 0x00,0x00,0x03,0xFE,0xFC,0x20,0x10,0x40,0x11,0xFC,0x11,0x04,0x11,0x24,0x11,0x24,
  135. 0x11,0x24,0x11,0x24,0x1D,0x24,0xE1,0x34,0x00,0x48,0x01,0x86,0x06,0x02,0x00,0x00,
  136. };

  137. code unsigned char Hz1616_shu[]=
  138. {
  139. /*--  文字:  数  --*/
  140. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  141. 0x08,0x20,0x49,0x30,0x2A,0x20,0x1C,0x20,0xFF,0x7E,0x1C,0x44,0x2B,0x44,0x48,0xC4,
  142. 0x08,0x28,0xFF,0x28,0x12,0x10,0x34,0x10,0x0C,0x28,0x32,0x4E,0xC0,0x84,0x00,0x00,
  143. };

  144. code unsigned char Hz1616_zhu[]=
  145. {
  146. /*--  文字:  组  --*/
  147. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  148. 0x10,0x00,0x19,0xF8,0x11,0x08,0x25,0x08,0x25,0x08,0x79,0xF8,0x09,0x08,0x11,0x08,
  149. 0x21,0x08,0x7D,0xF8,0x01,0x08,0x01,0x08,0x0D,0x08,0x73,0xFE,0x00,0x00,0x00,0x00,
  150. };

  151. code unsigned char Hz1616_zhi[]=
  152. {
  153. /*--  文字:  值  --*/
  154. /*--  宋体12;  此字体下对应的点阵为:宽x高=16x16   --*/
  155. 0x10,0x40,0x18,0x60,0x17,0xFC,0x10,0x40,0x20,0x80,0x33,0xF8,0x62,0x08,0xA3,0xF8,
  156. 0x22,0x08,0x23,0xF8,0x22,0x08,0x23,0xF8,0x22,0x08,0x22,0x08,0x2F,0xFE,0x20,0x00,
  157. };

  158. /* 注释一:
  159. * 以下是画布显示数组。横向是6个字节,纵向16行,可以显示3个16x16的汉字.
  160. *  注意,这节内容的画布跟前面79章节的画布大小不一样,79节前面的横向是4个字节,这节的横向是6个字节。
  161. */
  162. unsigned char ucCanvasBuffer[]=
  163. {
  164. 0x00,0x00,0x00,0x00,0x00,0x00,  //上半屏
  165. 0x00,0x00,0x00,0x00,0x00,0x00,
  166. 0x00,0x00,0x00,0x00,0x00,0x00,
  167. 0x00,0x00,0x00,0x00,0x00,0x00,
  168. 0x00,0x00,0x00,0x00,0x00,0x00,
  169. 0x00,0x00,0x00,0x00,0x00,0x00,
  170. 0x00,0x00,0x00,0x00,0x00,0x00,
  171. 0x00,0x00,0x00,0x00,0x00,0x00,

  172. //------------上半屏和下半屏的分割线-----------

  173. 0x00,0x00,0x00,0x00,0x00,0x00,  //下半屏
  174. 0x00,0x00,0x00,0x00,0x00,0x00,
  175. 0x00,0x00,0x00,0x00,0x00,0x00,
  176. 0x00,0x00,0x00,0x00,0x00,0x00,
  177. 0x00,0x00,0x00,0x00,0x00,0x00,
  178. 0x00,0x00,0x00,0x00,0x00,0x00,
  179. 0x00,0x00,0x00,0x00,0x00,0x00,
  180. 0x00,0x00,0x00,0x00,0x00,0x00,
  181. };


  182. /* 注释二:
  183. * 以下5个变量记录一个参数的5种信息,包括小数点的数量,小数点个数,数据的位置,数组具体值,整数个数
  184. */
  185. unsigned char ucDotCnt_1=0;  //记录当前输入的小数点数量,如果小数点的数量不为0,说明当前数组已包含小数点,此时再按小数点按键则无效
  186. unsigned char ucDotBitS_1=0; //记录当前输入的小数点个数,如果小数点的个数如果超过规定ucDotBitMax位,此时再按任何输入按键则无效
  187. unsigned char ucWdPartCnt_1=0; //记录当前输入的数据在数组中的位置。
  188. unsigned char ucDataBuffer_1[6]={0,10,10,10,10,10}; //一项的BCD码数组缓冲
  189. unsigned char ucIntCnt_1=0; //记录当前输入的整数个数,如果整数的个数如果超过规定ucIntCntMax位,此时再按任何输入按键则无效

  190. unsigned long ulData_1=0; //用一个long变量表示BCD码的具体数值。


  191. unsigned char ucKeyStep=1;  //按键扫描步骤变量

  192. unsigned char ucKeySec=0;   //被触发的按键编号
  193. unsigned int  uiKeyTimeCnt=0; //按键去抖动延时计数器
  194. unsigned char ucKeyLock=0; //按键触发后自锁的变量标志

  195. unsigned char ucRowRecord=1; //记录当前扫描到第几列了


  196. unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器


  197. unsigned char ucWd=1; //窗口变量
  198. unsigned char ucPart=1; //局部变量 0代表没有选中任何一行,其它数值1到4代表选中某一行


  199. unsigned char ucWd1Update=1; //窗口1的整屏更新显示变量      1代表更新显示,响应函数内部会清零
  200. unsigned char ucWd1Part1Update=0; //窗口1的第1行局部更新显示变量  1代表更新显示,响应函数内部会自动把它清零
  201. unsigned char ucWd1Part2Update=0; //窗口1的第2行局部更新显示变量  1代表更新显示,响应函数内部会自动把它清零

  202. void main()
  203.   {
  204.         initial_myself();      //第一区,上电后马上初始化
  205.         delay_long(100);       //一线,延时线。延时一段时间
  206.         initial_peripheral();  //第二区,上电后延时一段时间再初始化

  207.         while(1)   //第三区
  208.         {
  209.                     key_service(); //按键服务程序
  210.             lcd_display_service(); //应用层面的液晶屏显示程序
  211.         }

  212. }


  213. void initial_myself()  //第一区 上电后马上初始化
  214. {

  215.    beep_dr=1; //用PNP三极管控制蜂鸣器,输出高电平时不叫。

  216.    TMOD=0x01;  //设置定时器0为工作方式1

  217.    TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  218.    TL0=0x2f;
  219. }
  220. void initial_peripheral() //第二区 上电后延时一段时间再初始化
  221. {
  222.     LCDInit(); //初始化12864 内部包含液晶模块的复位


  223.     EA=1;     //开总中断
  224.     ET0=1;    //允许定时中断
  225.     TR0=1;    //启动定时中断

  226. }


  227. void T0_time() interrupt 1
  228. {
  229.   TF0=0;  //清除中断标志
  230.   TR0=0; //关中断

  231.   key_scan();//按键扫描函数 放在定时中断里

  232.   if(uiVoiceCnt!=0)
  233.   {
  234.      uiVoiceCnt--; //每次进入定时中断都自减1,直到等于零为止。才停止鸣叫
  235.          beep_dr=0;  //蜂鸣器是PNP三极管控制,低电平就开始鸣叫。
  236.   }
  237.   else
  238.   {
  239.      ; //此处多加一个空指令,想维持跟if括号语句的数量对称,都是两条指令。不加也可以。
  240.            beep_dr=1;  //蜂鸣器是PNP三极管控制,高电平就停止鸣叫。
  241.   }


  242.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  243.   TL0=0x2f;
  244.   TR0=1;  //开中断
  245. }


  246. void key_scan()//按键扫描函数 放在定时中断里
  247. {  

  248.   switch(ucKeyStep)
  249.   {
  250.      case 1:   //按键扫描输出第ucRowRecord列低电平
  251.               if(ucRowRecord==1)  //第一列输出低电平
  252.                   {
  253.              key_dr1=0;      
  254.              key_dr2=1;
  255.              key_dr3=1;   
  256.              key_dr4=1;
  257.                   }
  258.               else if(ucRowRecord==2)  //第二列输出低电平
  259.                   {
  260.              key_dr1=1;      
  261.              key_dr2=0;
  262.              key_dr3=1;   
  263.              key_dr4=1;
  264.                   }
  265.               else if(ucRowRecord==3)  //第三列输出低电平
  266.                   {
  267.              key_dr1=1;      
  268.              key_dr2=1;
  269.              key_dr3=0;   
  270.              key_dr4=1;
  271.                   }
  272.               else   //第四列输出低电平
  273.                   {
  274.              key_dr1=1;      
  275.              key_dr2=1;
  276.              key_dr3=1;   
  277.              key_dr4=0;
  278.                   }

  279.           uiKeyTimeCnt=0;  //延时计数器清零
  280.           ucKeyStep++;     //切换到下一个运行步骤
  281.               break;

  282.      case 2:     //此处的小延时用来等待刚才列输出信号稳定,再判断输入信号。不是去抖动延时。
  283.           uiKeyTimeCnt++;
  284.                   if(uiKeyTimeCnt>1)
  285.                   {
  286.                      uiKeyTimeCnt=0;
  287.              ucKeyStep++;     //切换到下一个运行步骤
  288.                   }
  289.               break;

  290.      case 3:
  291.           if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==1)
  292.           {  
  293.              ucKeyStep=1;  //如果没有按键按下,返回到第一个运行步骤重新开始扫描
  294.              ucKeyLock=0;  //按键自锁标志清零
  295.              uiKeyTimeCnt=0; //按键去抖动延时计数器清零,此行非常巧妙     
  296.    
  297.                          ucRowRecord++;  //输出下一列
  298.                          if(ucRowRecord>4)  
  299.                          {
  300.                             ucRowRecord=1; //依次输出完四列之后,继续从第一列开始输出低电平
  301.                          }

  302.           }
  303.                   else if(ucKeyLock==0)  //有按键按下,且是第一次触发
  304.                   {
  305.                      if(key_sr1==0&&key_sr2==1&&key_sr3==1&&key_sr4==1)
  306.                          {
  307.                             uiKeyTimeCnt++;  //去抖动延时计数器
  308.                                 if(uiKeyTimeCnt>const_key_time)
  309.                                 {
  310.                                    uiKeyTimeCnt=0;
  311.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零

  312.                        if(ucRowRecord==1)  //第一列输出低电平
  313.                            {
  314.                                       ucKeySec=1;  //触发1号键 对应朱兆祺学习板的S1键
  315.                            }
  316.                        else if(ucRowRecord==2)  //第二列输出低电平
  317.                            {
  318.                                       ucKeySec=2;  //触发2号键 对应朱兆祺学习板的S2键
  319.                            }
  320.                        else if(ucRowRecord==3)  //第三列输出低电平
  321.                            {
  322.                                       ucKeySec=3;  //触发3号键 对应朱兆祺学习板的S3键
  323.                            }
  324.                        else   //第四列输出低电平
  325.                            {
  326.                                       ucKeySec=4;  //触发4号键 对应朱兆祺学习板的S4键
  327.                            }

  328.                                 }
  329.                         
  330.                          }
  331.                      else if(key_sr1==1&&key_sr2==0&&key_sr3==1&&key_sr4==1)
  332.                          {
  333.                             uiKeyTimeCnt++;  //去抖动延时计数器
  334.                                 if(uiKeyTimeCnt>const_key_time)
  335.                                 {
  336.                                    uiKeyTimeCnt=0;
  337.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  338.                        if(ucRowRecord==1)  //第一列输出低电平
  339.                            {
  340.                                       ucKeySec=5;  //触发5号键 对应朱兆祺学习板的S5键
  341.                            }
  342.                        else if(ucRowRecord==2)  //第二列输出低电平
  343.                            {
  344.                                       ucKeySec=6;  //触发6号键 对应朱兆祺学习板的S6键
  345.                            }
  346.                        else if(ucRowRecord==3)  //第三列输出低电平
  347.                            {
  348.                                       ucKeySec=7;  //触发7号键 对应朱兆祺学习板的S7键
  349.                            }
  350.                        else   //第四列输出低电平
  351.                            {
  352.                                       ucKeySec=8;  //触发8号键 对应朱兆祺学习板的S8键
  353.                            }
  354.                                 }
  355.                         
  356.                          }
  357.                      else if(key_sr1==1&&key_sr2==1&&key_sr3==0&&key_sr4==1)
  358.                          {
  359.                             uiKeyTimeCnt++;  //去抖动延时计数器
  360.                                 if(uiKeyTimeCnt>const_key_time)
  361.                                 {
  362.                                    uiKeyTimeCnt=0;
  363.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  364.                        if(ucRowRecord==1)  //第一列输出低电平
  365.                            {
  366.                                       ucKeySec=9;  //触发9号键 对应朱兆祺学习板的S9键
  367.                            }
  368.                        else if(ucRowRecord==2)  //第二列输出低电平
  369.                            {
  370.                                       ucKeySec=10;  //触发10号键 对应朱兆祺学习板的S10键
  371.                            }
  372.                        else if(ucRowRecord==3)  //第三列输出低电平
  373.                            {
  374.                                       ucKeySec=11;  //触发11号键 对应朱兆祺学习板的S11键
  375.                            }
  376.                        else   //第四列输出低电平
  377.                            {
  378.                                       ucKeySec=12;  //触发12号键 对应朱兆祺学习板的S12键
  379.                            }
  380.                                 }
  381.                         
  382.                          }
  383.                      else if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==0)
  384.                          {
  385.                             uiKeyTimeCnt++;  //去抖动延时计数器
  386.                                 if(uiKeyTimeCnt>const_key_time)
  387.                                 {
  388.                                    uiKeyTimeCnt=0;
  389.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  390.                        if(ucRowRecord==1)  //第一列输出低电平
  391.                            {
  392.                                       ucKeySec=13;  //触发13号键 对应朱兆祺学习板的S13键
  393.                            }
  394.                        else if(ucRowRecord==2)  //第二列输出低电平
  395.                            {
  396.                                       ucKeySec=14;  //触发14号键 对应朱兆祺学习板的S14键
  397.                            }
  398.                        else if(ucRowRecord==3)  //第三列输出低电平
  399.                            {
  400.                                       ucKeySec=15;  //触发15号键 对应朱兆祺学习板的S15键
  401.                            }
  402.                        else   //第四列输出低电平
  403.                            {
  404.                                       ucKeySec=16;  //触发16号键 对应朱兆祺学习板的S16键
  405.                            }
  406.                                 }
  407.                         
  408.                          }
  409.                   
  410.                   }
  411.               break;

  412.   }


  413. }


  414. void key_service() //按键服务的应用程序
  415. {
  416.   switch(ucKeySec) //按键服务状态切换
  417.   {
  418.     case 1:// 数字1 对应朱兆祺学习板的S1键
  419.           key_number_input(1); //输入数字按键
  420.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  421.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  422.           break;        
  423.     case 2:// 数字2 对应朱兆祺学习板的S2键
  424.           key_number_input(2); //输入数字按键
  425.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  426.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  427.           break;     
  428.     case 3:// 数字3 对应朱兆祺学习板的S3键
  429.           key_number_input(3); //输入数字按键
  430.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  431.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  432.           break;         
  433.     case 4:// 数字4 对应朱兆祺学习板的S4键
  434.           key_number_input(4); //输入数字按键
  435.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  436.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  437.           break;   
  438.     case 5:// 数字5 对应朱兆祺学习板的S5键
  439.           key_number_input(5); //输入数字按键
  440.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  441.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  442.           break;   
  443.     case 6:// 数字6 对应朱兆祺学习板的S6键
  444.           key_number_input(6); //输入数字按键
  445.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  446.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  447.           break;   
  448.     case 7:// 数字7 对应朱兆祺学习板的S7键
  449.           key_number_input(7); //输入数字按键
  450.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  451.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  452.           break;   
  453.     case 8: //数字8 对应朱兆祺学习板的S8键
  454.           key_number_input(8); //输入数字按键
  455.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  456.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  457.           break;   
  458.     case 9:// 数字9 对应朱兆祺学习板的S9键
  459.           key_number_input(9); //输入数字按键
  460.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  461.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  462.           break;   
  463.     case 10:// 数字0  对应朱兆祺学习板的S10键
  464.           key_number_input(0); //输入数字按键
  465.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  466.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  467.           break;   
  468.     case 11:// 小数点按键 对应朱兆祺学习板的S11键
  469.           key_number_input(11); //输入数字按键  11代表小数点
  470.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  471.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  472.           break;   
  473.     case 12:// 本节暂时不用 对应朱兆祺学习板的S12键  

  474.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  475.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  476.           break;   
  477.     case 13:// 本节暂时不用 对应朱兆祺学习板的S13键   

  478.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  479.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  480.           break;   
  481.     case 14:// 本节暂时不用  对应朱兆祺学习板的S14键   
  482.         
  483.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  484.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  485.           break;   
  486.     case 15:// 本节暂时不用 对应朱兆祺学习板的S15键

  487.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  488.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  489.           break;   
  490.     case 16:// 清除按键 对应朱兆祺学习板的S16键
  491.           key_delete_input(); //删除按键
  492.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  493.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  494.           break;   
  495.   }               
  496. }



  497. void key_number_input(unsigned char ucKeyNumber) //输入数字按键
  498. {

  499.     switch(ucWd)
  500.     {
  501.        case 1:   //第1窗口。本节程序只有1个窗口
  502.              switch(ucPart)
  503.              {

  504.                  case 1:  //1窗口第1项
  505.                       set_data(ucKeyNumber,  //本函数跟前面第83节内容有所改动,请看本函数具体内容。本节的核心内容,值得好好研究!     
  506.                                                    2,  //小数点最大个数
  507.                                                            6,  //数组缓冲最大个数
  508.                                                        &ucDotCnt_1,
  509.                                                            &ucDotBitS_1,
  510.                                                            &ucWdPartCnt_1,
  511.                                                            ucDataBuffer_1,
  512.                                                            3, //整数部分的最大个数
  513.                                                            &ucIntCnt_1);

  514.                                           ulData_1=buffer_to_data(6,2,ucDataBuffer_1); //把带小数点的BCD码数组转换成long数值。
  515.                       ucWd1Part1Update=1;//第一行局部更新显示
  516.                                           ucWd1Part2Update=1;//第二行局部更新显示
  517.                       break;               
  518.              }
  519.                                        
  520.              break;
  521.     }                        
  522.                                 
  523. }


  524. /* 注释三:
  525. * 本函数在前面第83节内容的函数上有改动,为了限制整数部分的个数,多添加了第8和第9这两个参数。
  526. * 本节的核心函数,值得好好研究!
  527. * 涉及到参数的4种信息,包括小数点的数量,小数点的个数,数据的位置,数组具体值,整数的数量,整数的个数,以及它们之间的相互作用关系。
  528. * 以下参数,指针类型的参数是让代入的全局变量在退出函数后维持它当前最新更改的数值不变。
  529. * 第1个参数ucKeyNumberTemp是当前按键输入的数值。
  530. * 第2个参数ucDotBitMax是限定被设置参数的小数点最大位数。
  531. * 第3个参数ucDataCntMax是限定被设置参数的最大数组个数。
  532. * 第4个参数*p_ucDotCnt是记录当前输入的小数点数量,如果小数点的数量不为0,说明当前数组已包含小数点,此时再按小数点按键则无效。
  533. * 第5个参数*p_ucDotBitS是记录当前输入的小数点个数,如果小数点的个数如果超过规定ucDotBitMax位,此时再按任何输入按键则无效
  534. * 第6个参数*p_ucWdPartCnt是记录当前输入的数据在数组中的位置,方便锁定每次按键输入的数字显示位置。
  535. * 第7个参数*p_ucSetDataBuffer是BCD码数组缓冲的具体数字内容。
  536. * 第8个参数ucIntCntMax是限定被设置参数的整数部分的最大位数。
  537. * 第9个参数*p_ucIntCnt是记录当前输入的整数部分个数,如果整数部分的个数如果超过规定ucIntCntMax位,此时再按任何输入按键则无效
  538. */
  539. void set_data(unsigned char ucKeyNumberTemp,
  540.               unsigned char ucDotBitMax,
  541.               unsigned char ucDataCntMax,
  542.               unsigned char *p_ucDotCnt,
  543.               unsigned char *p_ucDotBitS,
  544.                           unsigned char *p_ucWdPartCnt,
  545.                           unsigned char *p_ucSetDataBuffer,
  546.                           unsigned char ucIntCntMax,
  547.                           unsigned char *p_ucIntCnt)
  548. {
  549.                     unsigned int i;

  550.                     if(ucKeyNumberTemp==11) //等于小数点
  551.                     {
  552.                        if(ucDotBitMax==0) //如果限定的小数点最大数是0,就意味着此数据不允许带小数点,必须是整数。
  553.                        {
  554.                            return; //直接返回退出
  555.                        }
  556.                        else if(*p_ucDotCnt>0)  //小数点个数大于0,意味着当前数组已经包含了小数点,此时再输入小数点则无效。
  557.                        {
  558.                            return; //直接返回退出
  559.                        }
  560.                        else  //否则有效,记录当前已经包含一个小数点的信息。
  561.                        {
  562.                            *p_ucDotCnt=1;  //只能包含一个小数点
  563.                        }
  564.                     }
  565.                     else  //如果输入的不是小数点
  566.                     {
  567.                         if(*p_ucDotCnt==1) //如果之前已经输入了一个小数点,那么此时输入的数字就是小数点后的数据
  568.                                                 {
  569.                            if(*p_ucDotBitS<ucDotBitMax) //如果小数点位数还没超过最大限制位数,则继续加1记录当前小数点位数。
  570.                            {
  571.                                *p_ucDotBitS=(*p_ucDotBitS)+1;
  572.                            }
  573.                            else //如果小数点位数已经超过允许的范围,则输入的按键无效,直接退出。
  574.                            {
  575.                               return; //直接返回退出
  576.                            }
  577.                                             }
  578.                                                 else if(*p_ucIntCnt<ucIntCntMax)//如果之前没有输入小数点,那么输入的就是整数个数超,整数个数没有超过极限
  579.                                                 {
  580.                                                     *p_ucIntCnt=(*p_ucIntCnt)+1;
  581.                                                 }
  582.                                                 else //整数个数超过极限
  583.                                                 {
  584.                              return; //直接返回退出
  585.                                                 }
  586.                     }

  587.             
  588.             
  589.                     if(*p_ucWdPartCnt==0&&p_ucSetDataBuffer[0]==0&&ucKeyNumberTemp!=11)  //如果当前默认位置是第0个位置,并且默认第0个数据是0,并且当前的按键输入不是小数点,则不用移位
  590.                     {
  591.                         ;
  592.                     }        
  593.                     else  //否则,移位
  594.                     {               
  595.                        for(i=0;i<(ucDataCntMax-1);i++)  //移位
  596.                        {
  597.                           p_ucSetDataBuffer[ucDataCntMax-1-i]=p_ucSetDataBuffer[ucDataCntMax-2-i];
  598.                        }
  599.                        *p_ucWdPartCnt=(*p_ucWdPartCnt)+1;
  600.                     }
  601.                     p_ucSetDataBuffer[0]=ucKeyNumberTemp; //当前输入的数字或者小数点永远在第右边第0个位置。
  602.                                                                
  603.         

  604. }


  605. /* 注释四:
  606. * 本节的核心函数,值得好好研究!
  607. * 功能:把一个带小数点的BCD码数组转换成一个long类型的数值。
  608. * 第1个参数ucConverDataSize是这个数组的最大有效个数。
  609. * 第2个参数ucConverDotCnt是这个数组要转换成的long数值带几个小数点
  610. * 第3个参数*p_ucConverBuffer是具体此数组的数据
  611. * 函数最后返回被转换的long数值。
  612. */
  613. unsigned long buffer_to_data(unsigned char ucConverDataSize,unsigned char ucConverDotCnt,unsigned char *p_ucConverBuffer)
  614. {
  615.    unsigned long ulConverResult=0;
  616.    unsigned long ulConverResultTemp=0;
  617.    unsigned char ucConverResultBuffer[6]; //因为本节内容的ucConverDataSize是6,所以取6.
  618.    unsigned char i;
  619.    unsigned char j;
  620.    unsigned char ucConverFlag;

  621.    for(i=0;i<ucConverDataSize;i++)
  622.    {
  623.       ucConverResultBuffer[i]=0;  //先把临时缓冲区清零
  624.    }

  625.    j=0;
  626.    ucConverFlag=0;
  627.    for(i=0;i<ucConverDataSize;i++)
  628.    {
  629.        if(p_ucConverBuffer[i]==11) //小数点
  630.        {
  631.           ucConverFlag=i; //记录小数点的位置
  632.        }
  633.        else if(p_ucConverBuffer[i]<10)
  634.        {
  635.           ucConverResultBuffer[j]=p_ucConverBuffer[i];  //提取数组中的有效数字
  636.           j++;
  637.        }


  638.    }


  639.    for(i=0;i<ucConverDataSize;i++)   //通过处理每一位从而合成一个long类型的数值
  640.    {
  641.        ulConverResultTemp=0;
  642.        ulConverResultTemp=ucConverResultBuffer[i];
  643.        for(j=0;j<i;j++)
  644.        {
  645.            ulConverResultTemp=ulConverResultTemp*10;  //把每一位对应的进位扩大到对应的倍数
  646.        }
  647.        ulConverResult=ulConverResult+ulConverResultTemp;
  648.    }


  649.    for(i=ucConverFlag;i<ucConverDotCnt;i++) //根据数组小数点的位置和实际要转换成的小数点个数,来扩大到对应的倍数。
  650.    {
  651.       ulConverResult=ulConverResult*10;
  652.    }

  653.    return ulConverResult;
  654. }

  655. void key_delete_input(void) //删除按键
  656. {
  657.     static unsigned int i;

  658.    switch(ucWd)
  659.    {
  660.       case 1:   //第1窗口。本节程序只有1个窗口
  661.            switch(ucPart)
  662.            {
  663.               case 1:  //1窗口第1项
  664.                     //清零
  665.                                         ulData_1=0; //long数值清零
  666.                                          ucIntCnt_1=0;
  667.                     ucDotBitS_1=0;  
  668.                     ucDotCnt_1=0;  
  669.                     ucWdPartCnt_1=0;               
  670.                     for(i=0;i<6;i++)  
  671.                     {
  672.                        ucDataBuffer_1[i]=10;
  673.                     }
  674.                     ucDataBuffer_1[0]=0; //第0个位置填入0
  675.         
  676.                     ucWd1Part1Update=1;//第一行局部更新显示
  677.                                     ucWd1Part2Update=1;//第二行局部更新显示
  678.                     break;               
  679.       
  680.            }
  681.                                        
  682.            break;
  683.         
  684.    }                        
  685.                                 
  686. }

  687. unsigned char *number_to_matrix(unsigned char  ucBitNumber)
  688. {
  689.     unsigned char *p_ucAnyNumber;  //此指针根据ucBitNumber数值的大小,分别调用不同的字库。

  690.         switch(ucBitNumber)  //根据ucBitNumber数值的大小,分别调用不同的字库。
  691.         {
  692.             case 0:
  693.              p_ucAnyNumber=Zf816_0;
  694.                      break;
  695.             case 1:
  696.              p_ucAnyNumber=Zf816_1;
  697.                      break;
  698.             case 2:
  699.              p_ucAnyNumber=Zf816_2;
  700.                      break;
  701.             case 3:
  702.              p_ucAnyNumber=Zf816_3;
  703.                      break;
  704.             case 4:
  705.              p_ucAnyNumber=Zf816_4;
  706.                      break;
  707.             case 5:
  708.              p_ucAnyNumber=Zf816_5;
  709.                      break;
  710.             case 6:
  711.              p_ucAnyNumber=Zf816_6;
  712.                      break;
  713.             case 7:
  714.              p_ucAnyNumber=Zf816_7;
  715.                      break;
  716.             case 8:
  717.              p_ucAnyNumber=Zf816_8;
  718.                      break;
  719.             case 9:
  720.              p_ucAnyNumber=Zf816_9;
  721.                      break;
  722.             case 10:  //空格
  723.              p_ucAnyNumber=Zf816_nc;
  724.                      break;
  725.                         case 11:   //小数点
  726.              p_ucAnyNumber=Zf816_dot;
  727.                      break;
  728.                 default:   //如果上面的条件都不符合,那么默认指向空字模
  729.              p_ucAnyNumber=Zf816_nc;
  730.                      break;
  731.         }

  732.     return p_ucAnyNumber;  //返回转换结束后的指针
  733. }



  734. void lcd_display_service(void) //应用层面的液晶屏显示程序
  735. {


  736.     static unsigned char *p_ucAnyNumber; //经过数字转换成字模后,分解变量的某位字模首地址
  737.     static unsigned char ucCursorFlag;  //光标标志,也就是反显的标志,它是根据局部变量ucPart来定的
  738.     static unsigned int i;
  739.         static unsigned char ucDataBuffer_temp[6]; //分解一个10进制的long类型数据的每一位

  740.     switch(ucWd)  //本程序的核心变量,窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。
  741.     {
  742.         case 1:   //显示窗口1的数据
  743.                if(ucWd1Update==1)  //窗口1整屏更新,里面只放那些不用经常刷新显示的内容
  744.                {
  745.                      ucWd1Update=0;  //及时清零,避免一直更新

  746.                      ucWd1Part1Update=1; //激活窗口1的第1行局部更新显示变量,这里在前面数码管显示框架上有所改进
  747.                      ucWd1Part2Update=1; //激活窗口1的第2行局部更新显示变量,这里在前面数码管显示框架上有所改进

  748.                      display_clear(0x00); // 清屏操作, 全部显示空填充0x00,全部显示点阵用0xff。
  749.                      clear_all_canvas();  //把画布全部清零

  750.                      display_lattice(0,0,Hz1616_yi,0,2,16,0);    //一项数组
  751.                      display_lattice(1,0,Hz1616_xiang,0,2,16,0);   
  752.                      display_lattice(2,0,Hz1616_shu,0,2,16,0);   
  753.                      display_lattice(3,0,Hz1616_zhu,0,2,16,0);
  754.                      display_lattice(4,0,Zf816_mao_hao,0,1,16,0); //冒号

  755.                      display_lattice(0,16,Hz1616_yi,0,2,16,0);    //一项数值
  756.                      display_lattice(1,16,Hz1616_xiang,0,2,16,0);   
  757.                      display_lattice(2,16,Hz1616_shu,0,2,16,0);   
  758.                      display_lattice(3,16,Hz1616_zhi,0,2,16,0);
  759.                      display_lattice(4,16,Zf816_mao_hao,0,1,16,0); //冒号              

  760.                }

  761.                if(ucWd1Part1Update==1) //窗口1的第1行局部更新显示变量,里面放一些经常需要刷新显示的内容
  762.                {
  763.                         ucWd1Part1Update=0; //及时清零,避免一直更新

  764.                         if(ucPart==1) //被选中
  765.                         {
  766.                            ucCursorFlag=1; //反显 显示
  767.                         }
  768.                         else //没被选中
  769.                         {
  770.                             ucCursorFlag=0; //正常 显示
  771.                         }

  772.                         
  773.                         for(i=0;i<6;i++) //把每个数组缓冲的字模依次插入画布
  774.                         {
  775.                             p_ucAnyNumber=number_to_matrix(ucDataBuffer_1[5-i]);
  776.                             insert_buffer_to_canvas(i,0,p_ucAnyNumber,0,1,16);  //这里的i是画布的横向地址,一共可以显示6个字符,因此取值范围是0到5
  777.                         }

  778.                         display_lattice(5,0,ucCanvasBuffer,ucCursorFlag,6,16,0);   //显示整屏的画布,最后的参数0是偏移量
  779.                }

  780.                if(ucWd1Part2Update==1) //窗口1的第2行局部更新显示变量,里面放一些经常需要刷新显示的内容
  781.                {
  782.                         ucWd1Part2Update=0; //及时清零,避免一直更新

  783.                         if(ucPart==2) //被选中
  784.                         {
  785.                            ucCursorFlag=1; //反显 显示
  786.                         }
  787.                         else //没被选中
  788.                         {
  789.                             ucCursorFlag=0; //正常 显示
  790.                         }

  791.                         if(ulData_1>=10000)
  792.                                                 {
  793.                                                    ucDataBuffer_temp[5]=ulData_1%100000/10000;
  794.                                                 }
  795.                                                 else
  796.                                                 {
  797.                                                    ucDataBuffer_temp[5]=10; //空格
  798.                                                 }

  799.                         if(ulData_1>=1000)
  800.                                                 {
  801.                                                       ucDataBuffer_temp[4]=ulData_1%10000/1000;
  802.                         }
  803.                                                 else
  804.                                                 {
  805.                                                       ucDataBuffer_temp[4]=10; //空格
  806.                         }

  807.                                                 ucDataBuffer_temp[3]=ulData_1%1000/100;
  808.                                                 ucDataBuffer_temp[2]=11;  //11代表小数点
  809.                                                 ucDataBuffer_temp[1]=ulData_1%100/10;
  810.                                                 ucDataBuffer_temp[0]=ulData_1%10/1;
  811.                         
  812.                         for(i=0;i<6;i++) //把每个数组缓冲的字模依次插入画布
  813.                         {
  814.                             p_ucAnyNumber=number_to_matrix(ucDataBuffer_temp[5-i]);
  815.                             insert_buffer_to_canvas(i,0,p_ucAnyNumber,0,1,16);  //这里的i是画布的横向地址,一共可以显示6个字符,因此取值范围是0到5
  816.                         }

  817.                         display_lattice(5,16,ucCanvasBuffer,ucCursorFlag,6,16,0);   //显示整屏的画布,最后的参数0是偏移量
  818.                }

  819.                      
  820.                break;
  821.         //本程序只有1个窗口,所以只有一个case 1,如果要增加窗口,就直接增加 case 2, case 3...        
  822.     }

  823. }



  824. void clear_all_canvas(void)  //把画布全部清零
  825. {
  826.    unsigned int j=0;
  827.    unsigned int i=0;

  828.    for(j=0;j<16;j++)  //这里的16表示画布有16行
  829.    {
  830.       for(i=0;i<4;i++) //这里的4表示画布每行有4个字节
  831.       {
  832.                   ucCanvasBuffer[j*4+i]=0x00;
  833.       }
  834.    }         

  835. }





  836. void display_clear(unsigned char ucFillDate) // 清屏  全部显示空填充0x00   全部显示点阵用0xff
  837. {   

  838.     unsigned char x,y;
  839.     WriteCommand(0x34);  //关显示缓冲指令            
  840.     WriteCommand(0x34);  //关显示缓冲指令  故意写2次,怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
  841.     y=0;
  842.     while(y<32)  //y轴的范围0至31
  843.     {
  844.          WriteCommand(y+0x80);        //垂直地址
  845.          WriteCommand(0x80);          //水平地址
  846.          for(x=0;x<32;x++)  //256个横向点,有32个字节
  847.          {  
  848.             LCDWriteData(ucFillDate);
  849.          }
  850.          y++;
  851.     }
  852.     WriteCommand(0x36); //开显示缓冲指令

  853. }

  854. /* 注释五:
  855. * 注意,这节内容的画布跟第79节前面的画布大小不一样,第79节前面的横向是4个字节,这节的横向是6个字节。
  856. * 把字模插入画布的函数.
  857. * 这是本节的核心函数,读者尤其要搞懂x_amount和y_amount对应的显示关系。
  858. * 第1,2个参数x,y是在画布中的坐标体系。
  859. * x的范围是0至5,因为画布的横向只要6个字节。y的范围是0至15,因为画布的纵向只有16行。
  860. * 第3个参数*ucArray是字模的数组。
  861. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示,1代表反白显示。
  862. * 第5,6个参数x_amount,y_amount分别代表字模数组的横向有多少个字节,纵向有几横。
  863. */
  864. void insert_buffer_to_canvas(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount)
  865. {
  866.    unsigned int j=0;
  867.    unsigned int i=0;
  868.    unsigned char ucTemp;
  869.    for(j=0;j<y_amount;j++)
  870.    {
  871.       for(i=0;i<x_amount;i++)
  872.       {
  873.               ucTemp=ucArray[j*x_amount+i];
  874.               if(ucFbFlag==0)
  875.               {
  876.                  ucCanvasBuffer[(y+j)*6+x+i]=ucTemp; //这里的6代表画布每一行只有6个字节。前面章节的横向是4个字节,要稍微注意的。
  877.               }
  878.               else
  879.               {
  880.                  ucCanvasBuffer[(y+j)*6+x+i]=~ucTemp; //这里的6代表画布每一行只有6个字节。前面章节的横向是4个字节,要稍微注意的。
  881.               }
  882.       }
  883.    }         

  884. }

  885. /* 注释六:
  886. * 显示任意点阵函数.
  887. * 注意,本函数在前几节的基础上多增加了第7个参数uiOffSetAddr,它是偏移地址。
  888. * 对于这个函数,读者尤其要搞懂x_amount和y_amount对应的显示关系。
  889. * 第1,2个参数x,y是坐标体系。x的范围是0至15,y的范围是0至31.
  890. * 第3个参数*ucArray是字模的数组。
  891. * 第4个参数ucFbFlag是反白显示标志。0代表正常显示,1代表反白显示。
  892. * 第5,6个参数x_amount,y_amount分别代表字模数组的横向有多少个字节,纵向有几横。
  893. * 第7个参数uiOffSetAddr是偏移地址,代表字模数组的从第几个数据开始显示。
  894. */
  895. void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount,unsigned int uiOffSetAddr)
  896. {
  897.    unsigned int j=0;
  898.    unsigned int i=0;
  899.    unsigned char ucTemp;

  900. //注意,要把以下两行指令屏蔽,否则屏幕在更新显示时会整屏闪动
  901. //  WriteCommand(0x34);  //关显示缓冲指令            
  902. //  WriteCommand(0x34);  //关显示缓冲指令  故意写2次,怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
  903.    for(j=0;j<y_amount;j++) //y_amount代表y轴有多少横
  904.    {
  905.        WriteCommand(y+j+0x80);        //垂直地址
  906.        WriteCommand(x+0x80);          //水平地址
  907.        for(i=0;i<x_amount;i++) //x_amount代表x轴有多少列
  908.        {
  909.            ucTemp=ucArray[j*x_amount+i+uiOffSetAddr]; //uiOffSetAddr是字模数组的偏移地址
  910.            if(ucFbFlag==1)  //反白显示
  911.            {
  912.                ucTemp=~ucTemp;
  913.            }
  914.            LCDWriteData(ucTemp);
  915.           //         delay_short(30000);  //把上一节这个延时函数去掉,加快刷屏速度
  916.       }
  917.    }
  918.    WriteCommand(0x36); //开显示缓冲指令
  919. }




  920. void SendByteToLcd(unsigned char ucData)  //发送一个字节数据到液晶模块
  921. {
  922.         unsigned char i;
  923.         for ( i = 0; i < 8; i++ )
  924.         {
  925.                 if ( (ucData << i) & 0x80 )
  926.                 {
  927.                         LCDSID_dr = 1;
  928.                 }
  929.                 else
  930.                 {
  931.                         LCDSID_dr = 0;
  932.                 }
  933.                 LCDCLK_dr = 0;
  934.                 LCDCLK_dr = 1;
  935.         }
  936. }

  937. void SPIWrite(unsigned char ucWData, unsigned char ucWRS) //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
  938. {
  939.         SendByteToLcd( 0xf8 + (ucWRS << 1) );
  940.         SendByteToLcd( ucWData & 0xf0 );
  941.         SendByteToLcd( (ucWData << 4) & 0xf0);
  942. }


  943. void WriteCommand(unsigned char ucCommand) //发送一个字节的命令给液晶模块
  944. {

  945.         LCDCS_dr = 0;
  946.         LCDCS_dr = 1;
  947.         SPIWrite(ucCommand, 0);
  948.         delay_short(90);
  949. }

  950. void LCDWriteData(unsigned char ucData)  //发送一个字节的数据给液晶模块
  951. {
  952.         LCDCS_dr = 0;
  953.         LCDCS_dr = 1;
  954.         SPIWrite(ucData, 1);
  955. }

  956. void LCDInit(void) //初始化  函数内部包括液晶模块的复位
  957. {
  958.         LCDRST_dr = 1;  //复位
  959.         LCDRST_dr = 0;
  960.         LCDRST_dr = 1;
  961. }



  962. void delay_short(unsigned int uiDelayShort) //延时函数
  963. {
  964.    unsigned int i;  
  965.    for(i=0;i<uiDelayShort;i++)
  966.    {
  967.      ;  
  968.    }
  969. }


  970. void delay_long(unsigned int uiDelayLong)
  971. {
  972.    unsigned int i;
  973.    unsigned int j;
  974.    for(i=0;i<uiDelayLong;i++)
  975.    {
  976.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  977.           {
  978.              ; //一个分号相当于执行一条空语句
  979.           }
  980.    }
  981. }


复制代码

总结陈词:
    这节讲了把BCD码数组同步实时转换成数值的算法程序,相反,把数值转换成BCD码数组的逆运算程序应该怎么写?欲知详情,请听下回分解----实时同步把加减按键输入的数值转换成BCD码数组的液晶屏显示程序。

(未完待续,下节更精彩,不要走开哦)

此帖出自51单片机论坛

回复

98

帖子

0

TA的资源

一粒金砂(高级)

第三十三节:能设置速度档位的数码管倒计时程序。

开场白:
   上一节讲了数码管中的倒计时程序。这节要在此程序上多增加两个按键,用来控制数码管倒计时的速度档位,并且需要在数码管中闪烁显示被设置的速度档位。这一节要教会大家三个知识点:
第一个:把一个按键的短按与长按复合应用在项目中的程序结构。
第二个:通过本程序,继续加深理解按键与数码管的关联方法。
第三个:继续加深熟悉鸿哥首次提出的“一二级菜单显示理论”:凡是人机界面显示,不管是数码管还是液晶屏,都可以把显示的内容分成不同的窗口来显示,每个显示的窗口中又可以分成不同的局部显示。其中窗口就是一级菜单,用ucWd变量表示。局部就是二级菜单,用ucPart来表示。不同的窗口,会有不同的更新显示变量ucWdXUpdate来对应,表示整屏全部更新显示。不同的局部,也会有不同的更新显示变量ucWdXPartYUpdate来对应,表示局部更新显示。

具体内容,请看源代码讲解。

(1)硬件平台:基于朱兆祺51单片机学习板。启动和暂停键对应S1键,复位键对应S5键。加键对应S9键,减键对应S13键。

(2)实现功能:按下启动暂停按键时,倒计时开始工作,再按一次启动暂停按键时,则暂停倒计时。在任何时候,按下复位按键,倒计时将暂停工作,并且恢复倒计时当前默认值99。如果长按复位按键,在数码管会切换到第2个闪烁窗口,用来设置速度档位,修改完速度档位后,再一次按下复位按键,或者直接按启动暂停按键,会切换回窗口1显示倒计时的当前数据。
     
(3)源代码讲解如下:

  1. #include "REG52.H"


  2. #define const_voice_short  40   //蜂鸣器短叫的持续时间
  3. #define const_voice_long   200    //蜂鸣器长叫的持续时间

  4. #define const_key_time1  20    //按键去抖动延时的时间
  5. #define const_key_time2  20    //按键去抖动延时的时间
  6. #define const_key_time3  20    //按键去抖动延时的时间
  7. #define const_key_time4  20    //按键去抖动延时的时间

  8. #define const_key_long_time 200  //长按复位按键的时间


  9. #define const_dpy_time_half  200  //数码管闪烁时间的半值
  10. #define const_dpy_time_all   400  //数码管闪烁时间的全值 一定要比const_dpy_time_half 大


  11. void initial_myself();   
  12. void initial_peripheral();
  13. void delay_short(unsigned int uiDelayShort);
  14. void delay_long(unsigned int uiDelaylong);

  15. //驱动数码管的74HC595
  16. void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01);  
  17. void display_drive(); //显示数码管字模的驱动函数

  18. void display_service(); //显示的窗口菜单服务程序

  19. //驱动LED的74HC595
  20. void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01);

  21. void T0_time();  //定时中断函数
  22. void key_service(); //按键服务的应用程序
  23. void key_scan();//按键扫描函数 放在定时中断里


  24. sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
  25. sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键
  26. sbit key_sr3=P0^2; //对应朱兆祺学习板的S9键
  27. sbit key_sr4=P0^3; //对应朱兆祺学习板的S13键


  28. sbit key_gnd_dr=P0^4; //模拟独立按键的地GND,因此必须一直输出低电平

  29. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
  30. sbit led_dr=P3^5;  //作为中途暂停指示灯 亮的时候表示中途暂停


  31. sbit dig_hc595_sh_dr=P2^0;     //数码管的74HC595程序
  32. sbit dig_hc595_st_dr=P2^1;  
  33. sbit dig_hc595_ds_dr=P2^2;  

  34. sbit hc595_sh_dr=P2^3;    //LED灯的74HC595程序
  35. sbit hc595_st_dr=P2^4;  
  36. sbit hc595_ds_dr=P2^5;  

  37. unsigned char ucKeySec=0;   //被触发的按键编号

  38. unsigned int  uiKeyTimeCnt1=0; //按键去抖动延时计数器
  39. unsigned char ucKeyLock1=0; //按键触发后自锁的变量标志

  40. unsigned int  uiKeyTimeCnt2=0; //按键去抖动延时计数器
  41. unsigned char ucKeyLock2=0; //按键触发后自锁的变量标志

  42. unsigned int  uiKeyTimeCnt3=0; //按键去抖动延时计数器
  43. unsigned char ucKeyLock3=0; //按键触发后自锁的变量标志

  44. unsigned int  uiKeyTimeCnt4=0; //按键去抖动延时计数器
  45. unsigned char ucKeyLock4=0; //按键触发后自锁的变量标志




  46. unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器


  47. unsigned char ucDigShow8;  //第8位数码管要显示的内容
  48. unsigned char ucDigShow7;  //第7位数码管要显示的内容
  49. unsigned char ucDigShow6;  //第6位数码管要显示的内容
  50. unsigned char ucDigShow5;  //第5位数码管要显示的内容
  51. unsigned char ucDigShow4;  //第4位数码管要显示的内容
  52. unsigned char ucDigShow3;  //第3位数码管要显示的内容
  53. unsigned char ucDigShow2;  //第2位数码管要显示的内容
  54. unsigned char ucDigShow1;  //第1位数码管要显示的内容


  55. unsigned char ucDigDot8;  //数码管8的小数点是否显示的标志
  56. unsigned char ucDigDot7;  //数码管7的小数点是否显示的标志
  57. unsigned char ucDigDot6;  //数码管6的小数点是否显示的标志
  58. unsigned char ucDigDot5;  //数码管5的小数点是否显示的标志
  59. unsigned char ucDigDot4;  //数码管4的小数点是否显示的标志
  60. unsigned char ucDigDot3;  //数码管3的小数点是否显示的标志
  61. unsigned char ucDigDot2;  //数码管2的小数点是否显示的标志
  62. unsigned char ucDigDot1;  //数码管1的小数点是否显示的标志

  63. unsigned char ucDigShowTemp=0; //临时中间变量
  64. unsigned char ucDisplayDriveStep=1;  //动态扫描数码管的步骤变量

  65. unsigned char ucWd=1;  //本程序的核心变量,窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。
  66. unsigned char ucWd1Update=1; //窗口1更新显示标志
  67. unsigned char ucWd2Update=1; //窗口2更新显示标志

  68. unsigned char ucCountDown=99;  //倒计时的当前值
  69. unsigned char ucStartFlag=0;  //暂停与启动的标志位
  70. unsigned int  uiTimeCnt=0;  //倒计时的时间计时器

  71. unsigned int  uiDpyTimeCnt=0;  //数码管的闪烁计时器,放在定时中断里不断累加

  72. unsigned int  uiSetData1=50;  //速度档位
  73. unsigned int  uiSpeedCnt=400;  //影响速度变量,它跟速度档位uiSetData1有关联

  74. unsigned char ucTemp1=0;  //中间过渡变量
  75. unsigned char ucTemp2=0;  //中间过渡变量
  76. unsigned char ucTemp3=0;  //中间过渡变量
  77. unsigned char ucTemp4=0;  //中间过渡变量
  78. unsigned char ucTemp5=0;  //中间过渡变量
  79. unsigned char ucTemp6=0;  //中间过渡变量
  80. unsigned char ucTemp7=0;  //中间过渡变量
  81. unsigned char ucTemp8=0;  //中间过渡变量


  82. //根据原理图得出的共阴数码管字模表
  83. code unsigned char dig_table[]=
  84. {
  85. 0x3f,  //0       序号0
  86. 0x06,  //1       序号1
  87. 0x5b,  //2       序号2
  88. 0x4f,  //3       序号3
  89. 0x66,  //4       序号4
  90. 0x6d,  //5       序号5
  91. 0x7d,  //6       序号6
  92. 0x07,  //7       序号7
  93. 0x7f,  //8       序号8
  94. 0x6f,  //9       序号9
  95. 0x00,  //无      序号10
  96. 0x40,  //-       序号11
  97. 0x73,  //P       序号12
  98. };

  99. void main()
  100.   {
  101.    initial_myself();  
  102.    delay_long(100);   
  103.    initial_peripheral();
  104.    while(1)  
  105.    {
  106.        key_service(); //按键服务的应用程序
  107.        display_service(); //显示的窗口菜单服务程序
  108.    }

  109. }



  110. /* 注释一:
  111. *鸿哥首次提出的"一二级菜单显示理论":
  112. *凡是人机界面显示,不管是数码管还是液晶屏,都可以把显示的内容分成不同的窗口来显示,
  113. *每个显示的窗口中又可以分成不同的局部显示。其中窗口就是一级菜单,用ucWd变量表示。
  114. *局部就是二级菜单,用ucPart来表示。不同的窗口,会有不同的更新显示变量ucWdXUpdate来对应,
  115. *表示整屏全部更新显示。不同的局部,也会有不同的更新显示变量ucWdXPartYUpdate来对应,表示局部更新显示。
  116. */


  117. void display_service() //显示的窗口菜单服务程序
  118. {


  119.    switch(ucWd)  //本程序的核心变量,窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。
  120.    {
  121.        case 1:   //显示窗口1的数据
  122.             if(ucWd1Update==1)  //窗口1要全部更新显示
  123.                         {
  124.                ucWd1Update=0;  //及时清零标志,避免一直进来扫描

  125.                ucTemp8=10;  //显示空
  126.                ucTemp7=10;  //显示空
  127.                ucTemp6=10;  //显示空
  128.                ucTemp5=10;  //显示空
  129.                ucTemp4=10;  //显示空
  130.                ucTemp3=10;  //显示空

  131.                ucTemp2=ucCountDown/10;  //倒计时的当前值
  132.                ucTemp1=ucCountDown%10;


  133.                ucDigShow8=ucTemp8;  
  134.                ucDigShow7=ucTemp7;  
  135.                ucDigShow6=ucTemp6;  
  136.                ucDigShow5=ucTemp5;
  137.                ucDigShow4=ucTemp4;  
  138.                ucDigShow3=ucTemp3;


  139.                            if(ucCountDown<10)
  140.                            {
  141.                               ucDigShow2=10;
  142.                            }
  143.                            else
  144.                            {
  145.                               ucDigShow2=ucTemp2;
  146.                            }
  147.                            ucDigShow1=ucTemp1;

  148.                        

  149.             }
  150.             break;
  151.        case 2:   //显示窗口2的数据
  152.             if(ucWd2Update==1)  //窗口2要全部更新显示
  153.             {
  154.                ucWd2Update=0;  //及时清零标志,避免一直进来扫描

  155.                ucTemp8=10;  //显示空
  156.                ucTemp7=10;  //显示空
  157.                ucTemp6=10;  //显示空
  158.                ucTemp5=10;  //显示空
  159.                ucTemp4=10;  //显示空
  160.                ucTemp3=10;  //显示空

  161.                ucTemp2=uiSetData1/10;  //倒计时的速度档位
  162.                ucTemp1=uiSetData1%10;


  163.                ucDigShow8=ucTemp8;  
  164.                ucDigShow7=ucTemp7;  
  165.                ucDigShow6=ucTemp6;  
  166.                ucDigShow5=ucTemp5;
  167.                ucDigShow4=ucTemp4;  
  168.                ucDigShow3=ucTemp3;


  169.                            if(uiSetData1<10)
  170.                            {
  171.                               ucDigShow2=10;
  172.                            }
  173.                            else
  174.                            {
  175.                               ucDigShow2=ucTemp2;
  176.                            }
  177.                            ucDigShow1=ucTemp1;

  178.                         

  179.             }

  180.             //数码管闪烁
  181.             if(uiDpyTimeCnt==const_dpy_time_half)
  182.             {
  183.                if(uiSetData1<10)        //数码管显示内容
  184.                {
  185.                     ucDigShow2=10;
  186.                }
  187.                else
  188.                {
  189.                     ucDigShow2=ucTemp2;
  190.                }
  191.                ucDigShow1=ucTemp1;
  192.             }
  193.             else if(uiDpyTimeCnt>const_dpy_time_all) //const_dpy_time_all一定要比const_dpy_time_half 大
  194.             {                       
  195.                uiDpyTimeCnt=0;   //及时把闪烁记时器清零                          

  196.                ucDigShow2=10;   //数码管显示空,什么都不显示
  197.                ucDigShow1=10;

  198.             }

  199.             break;

  200.    
  201.      }
  202.    


  203. }


  204. void key_scan()//按键扫描函数 放在定时中断里
  205. {  

  206.   if(key_sr1==1)//IO是高电平,说明按键没有被按下,这时要及时清零一些标志位
  207.   {
  208.      ucKeyLock1=0; //按键自锁标志清零
  209.      uiKeyTimeCnt1=0;//按键去抖动延时计数器清零,此行非常巧妙,是我实战中摸索出来的。      
  210.   }
  211.   else if(ucKeyLock1==0)//有按键按下,且是第一次被按下
  212.   {
  213.      uiKeyTimeCnt1++; //累加定时中断次数
  214.      if(uiKeyTimeCnt1>const_key_time1)
  215.      {
  216.         uiKeyTimeCnt1=0;
  217.         ucKeyLock1=1;  //自锁按键置位,避免一直触发
  218.         ucKeySec=1;    //触发1号键
  219.      }
  220.   }

  221. /* 注释二:
  222. * 请注意以下长按复位按键与短按复位按键的写法。在本程序中,每次长按复位按键必然
  223. * 触发一次短按复位按键。
  224. */

  225.   if(key_sr2==1)//IO是高电平,说明按键没有被按下,这时要及时清零一些标志位
  226.   {
  227.      ucKeyLock2=0; //按键自锁标志清零
  228.      uiKeyTimeCnt2=0;//按键去抖动延时计数器清零,此行非常巧妙,是我实战中摸索出来的。      
  229.   }
  230.   else if(ucKeyLock2==0)//有按键按下,且是第一次被按下
  231.   {
  232.      uiKeyTimeCnt2++; //累加定时中断次数
  233.      if(uiKeyTimeCnt2>const_key_time2)
  234.      {
  235.         uiKeyTimeCnt2=0;
  236.         ucKeyLock2=1;  //自锁按键置位,避免一直触发
  237.         ucKeySec=2;    //触发2号键
  238.      }
  239.   }
  240.   else if(uiKeyTimeCnt2<const_key_long_time)   //长按复位按键
  241.   {
  242.       uiKeyTimeCnt2++;
  243.           if(uiKeyTimeCnt2==const_key_long_time)
  244.           {
  245.              ucKeySec=17;    //触发17号长按复位键
  246.           }
  247.   }

  248. if(key_sr3==1)//IO是高电平,说明按键没有被按下,这时要及时清零一些标志位
  249.   {
  250.      ucKeyLock3=0; //按键自锁标志清零
  251.      uiKeyTimeCnt3=0;//按键去抖动延时计数器清零,此行非常巧妙,是我实战中摸索出来的。      
  252.   }
  253.   else if(ucKeyLock3==0)//有按键按下,且是第一次被按下
  254.   {
  255.      uiKeyTimeCnt3++; //累加定时中断次数
  256.      if(uiKeyTimeCnt3>const_key_time3)
  257.      {
  258.         uiKeyTimeCnt3=0;
  259.         ucKeyLock3=1;  //自锁按键置位,避免一直触发
  260.         ucKeySec=3;    //触发3号键
  261.      }
  262.   }

  263.   if(key_sr4==1)//IO是高电平,说明按键没有被按下,这时要及时清零一些标志位
  264.   {
  265.      ucKeyLock4=0; //按键自锁标志清零
  266.      uiKeyTimeCnt4=0;//按键去抖动延时计数器清零,此行非常巧妙,是我实战中摸索出来的。      
  267.   }
  268.   else if(ucKeyLock4==0)//有按键按下,且是第一次被按下
  269.   {
  270.      uiKeyTimeCnt4++; //累加定时中断次数
  271.      if(uiKeyTimeCnt4>const_key_time4)
  272.      {
  273.         uiKeyTimeCnt4=0;
  274.         ucKeyLock4=1;  //自锁按键置位,避免一直触发
  275.         ucKeySec=4;    //触发4号键
  276.      }
  277.   }




  278. }


  279. void key_service() //按键服务的应用程序
  280. {
  281.   switch(ucKeySec) //按键服务状态切换
  282.   {
  283.     case 1:// 启动和暂停按键 对应朱兆祺学习板的S1键

  284.           switch(ucWd)  //在不同的窗口下,设置不同的参数
  285.           {
  286.               case 1:
  287.                    if(ucStartFlag==0)  //如果原来处于暂停的状态,则启动
  288.                                    {
  289.                       ucStartFlag=1; //启动
  290.                                    }
  291.                                    else     //如果原来处于启动的状态,则暂停
  292.                                    {
  293.                                       ucStartFlag=0;  //暂停
  294.                                    }
  295.                    break;


  296.            
  297.           }   

  298.           ucWd=1;  //不管在哪个窗口,强行切换回窗口1
  299.                   ucWd1Update=1; //窗口1更新显示标志

  300.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  301.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  302.           break;   
  303.    
  304.     case 2:// 复位按键 对应朱兆祺学习板的S5键

  305.           switch(ucWd)  //在不同的窗口下,设置不同的参数
  306.           {
  307.               case 1:    //在窗口1中
  308.                                    ucStartFlag=0;  //暂停
  309.                    ucCountDown=99;  //恢复倒计时的默认值99
  310.                    uiTimeCnt=0;  //倒计时的时间计时器清零
  311.                                    ucWd1Update=1; //窗口1更新显示标志  只要ucCountDown变化了,就要更新显示一次
  312.                    break;
  313.               case 2:    //在窗口2中
  314.                    ucWd=1;  //切换回窗口1
  315.                                    ucWd1Update=1; //窗口1更新显示标志
  316.                    break;
  317.           }  
  318.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  319.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  320.           break;  

  321.     case 3:// 加按键 对应朱兆祺学习板的S9键


  322.           switch(ucWd)  //在不同的窗口下,设置不同的参数
  323.           {
  324.               case 2:   //在窗口2中
  325.                    uiSetData1++;       //速度档位累加,档位越大,速度越快.
  326.                                    if(uiSetData1>99)
  327.                                    {
  328.                                       uiSetData1=99;
  329.                                    }
  330.                    uiSpeedCnt=440-(uiSetData1*2);  //速度档位越大,累计中断数uiSpeedCnt越小,从而倒计时的时间越快

  331.                                    ucWd2Update=1; //窗口2更新显示
  332.                    break;
  333.           }     
  334.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  335.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  336.           break;   
  337.    
  338.     case 4:// 减按键 对应朱兆祺学习板的S13键
  339.           switch(ucWd)  //在不同的窗口下,设置不同的参数
  340.           {
  341.               case 2:   //在窗口2中
  342.                                if(uiSetData1>0)  //加此条件判断,避免0减1
  343.                                    {
  344.                       uiSetData1--;       //速度档位累减,档位越小,速度越慢.
  345.                                    }

  346.                    uiSpeedCnt=440-(uiSetData1*2);  //速度档位越小,累计中断数uiSpeedCnt越大,从而倒计时的时间越慢

  347.                                    ucWd2Update=1; //窗口2更新显示
  348.                    break;
  349.           }
  350.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  351.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  352.           break;

  353.     case 17:// 长按复位按键 对应朱兆祺学习板的S5键

  354.           switch(ucWd)  //在不同的窗口下,设置不同的参数
  355.           {
  356.               case 1:  //窗口1下
  357.                    ucWd=2;  //切换到闪烁窗口2  进行设置速度档位显示
  358.                                    ucWd2Update=1; //窗口2更新显示标志
  359.                    break;
  360.          
  361.           }  
  362.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  363.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  364.           break;

  365.   }               
  366. }


  367. void display_drive()  
  368. {
  369.    //以下程序,如果加一些数组和移位的元素,还可以压缩容量。但是鸿哥追求的不是容量,而是清晰的讲解思路
  370.    switch(ucDisplayDriveStep)
  371.    {
  372.       case 1:  //显示第1位
  373.            ucDigShowTemp=dig_table[ucDigShow1];
  374.                    if(ucDigDot1==1)
  375.                    {
  376.                       ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
  377.                    }
  378.            dig_hc595_drive(ucDigShowTemp,0xfe);
  379.                break;
  380.       case 2:  //显示第2位
  381.            ucDigShowTemp=dig_table[ucDigShow2];
  382.                    if(ucDigDot2==1)
  383.                    {
  384.                       ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
  385.                    }
  386.            dig_hc595_drive(ucDigShowTemp,0xfd);
  387.                break;
  388.       case 3:  //显示第3位
  389.            ucDigShowTemp=dig_table[ucDigShow3];
  390.                    if(ucDigDot3==1)
  391.                    {
  392.                       ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
  393.                    }
  394.            dig_hc595_drive(ucDigShowTemp,0xfb);
  395.                break;
  396.       case 4:  //显示第4位
  397.            ucDigShowTemp=dig_table[ucDigShow4];
  398.                    if(ucDigDot4==1)
  399.                    {
  400.                       ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
  401.                    }
  402.            dig_hc595_drive(ucDigShowTemp,0xf7);
  403.                break;
  404.       case 5:  //显示第5位
  405.            ucDigShowTemp=dig_table[ucDigShow5];
  406.                    if(ucDigDot5==1)
  407.                    {
  408.                       ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
  409.                    }
  410.            dig_hc595_drive(ucDigShowTemp,0xef);
  411.                break;
  412.       case 6:  //显示第6位
  413.            ucDigShowTemp=dig_table[ucDigShow6];
  414.                    if(ucDigDot6==1)
  415.                    {
  416.                       ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
  417.                    }
  418.            dig_hc595_drive(ucDigShowTemp,0xdf);
  419.                break;
  420.       case 7:  //显示第7位
  421.            ucDigShowTemp=dig_table[ucDigShow7];
  422.                    if(ucDigDot7==1)
  423.                    {
  424.                       ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
  425.            }
  426.            dig_hc595_drive(ucDigShowTemp,0xbf);
  427.                break;
  428.       case 8:  //显示第8位
  429.            ucDigShowTemp=dig_table[ucDigShow8];
  430.                    if(ucDigDot8==1)
  431.                    {
  432.                       ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
  433.                    }
  434.            dig_hc595_drive(ucDigShowTemp,0x7f);
  435.                break;
  436.    }

  437.    ucDisplayDriveStep++;
  438.    if(ucDisplayDriveStep>8)  //扫描完8个数码管后,重新从第一个开始扫描
  439.    {
  440.      ucDisplayDriveStep=1;
  441.    }



  442. }


  443. //数码管的74HC595驱动函数
  444. void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01)
  445. {
  446.    unsigned char i;
  447.    unsigned char ucTempData;
  448.    dig_hc595_sh_dr=0;
  449.    dig_hc595_st_dr=0;

  450.    ucTempData=ucDigStatusTemp16_09;  //先送高8位
  451.    for(i=0;i<8;i++)
  452.    {
  453.          if(ucTempData>=0x80)dig_hc595_ds_dr=1;
  454.          else dig_hc595_ds_dr=0;

  455.          dig_hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
  456.          delay_short(1);
  457.          dig_hc595_sh_dr=1;
  458.          delay_short(1);

  459.          ucTempData=ucTempData<<1;
  460.    }

  461.    ucTempData=ucDigStatusTemp08_01;  //再先送低8位
  462.    for(i=0;i<8;i++)
  463.    {
  464.          if(ucTempData>=0x80)dig_hc595_ds_dr=1;
  465.          else dig_hc595_ds_dr=0;

  466.          dig_hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
  467.          delay_short(1);
  468.          dig_hc595_sh_dr=1;
  469.          delay_short(1);

  470.          ucTempData=ucTempData<<1;
  471.    }

  472.    dig_hc595_st_dr=0;  //ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
  473.    delay_short(1);
  474.    dig_hc595_st_dr=1;
  475.    delay_short(1);

  476.    dig_hc595_sh_dr=0;    //拉低,抗干扰就增强
  477.    dig_hc595_st_dr=0;
  478.    dig_hc595_ds_dr=0;

  479. }


  480. //LED灯的74HC595驱动函数
  481. void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01)
  482. {
  483.    unsigned char i;
  484.    unsigned char ucTempData;
  485.    hc595_sh_dr=0;
  486.    hc595_st_dr=0;

  487.    ucTempData=ucLedStatusTemp16_09;  //先送高8位
  488.    for(i=0;i<8;i++)
  489.    {
  490.          if(ucTempData>=0x80)hc595_ds_dr=1;
  491.          else hc595_ds_dr=0;

  492.          hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
  493.          delay_short(1);
  494.          hc595_sh_dr=1;
  495.          delay_short(1);

  496.          ucTempData=ucTempData<<1;
  497.    }

  498.    ucTempData=ucLedStatusTemp08_01;  //再先送低8位
  499.    for(i=0;i<8;i++)
  500.    {
  501.          if(ucTempData>=0x80)hc595_ds_dr=1;
  502.          else hc595_ds_dr=0;

  503.          hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
  504.          delay_short(1);
  505.          hc595_sh_dr=1;
  506.          delay_short(1);

  507.          ucTempData=ucTempData<<1;
  508.    }

  509.    hc595_st_dr=0;  //ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
  510.    delay_short(1);
  511.    hc595_st_dr=1;
  512.    delay_short(1);

  513.    hc595_sh_dr=0;    //拉低,抗干扰就增强
  514.    hc595_st_dr=0;
  515.    hc595_ds_dr=0;

  516. }


  517. void T0_time() interrupt 1
  518. {
  519.   TF0=0;  //清除中断标志
  520.   TR0=0; //关中断

  521.   key_scan(); //按键扫描函数


  522.   if(ucStartFlag==1)  //启动倒计时的计时器
  523.   {
  524.      uiTimeCnt++;
  525.      if(uiTimeCnt>=uiSpeedCnt)    //时间到
  526.      {
  527.             if(ucCountDown!=0) //加这个判断,就是避免在0的情况下减1
  528.             {
  529.                ucCountDown--;  //倒计时当前显示值减1
  530.             }

  531.         if(ucCountDown==0)  //倒计时结束
  532.             {
  533.                ucStartFlag=0;  //暂停
  534.            uiVoiceCnt=const_voice_long; //蜂鸣器触发提醒,滴一声就停。
  535.             }

  536.         ucWd1Update=1; //窗口1更新显示标志
  537.         uiTimeCnt=0;   //计时器清零,准备从新开始计时
  538.      }
  539.   }


  540.   uiDpyTimeCnt++;  //数码管的闪烁计时器


  541.   if(uiVoiceCnt!=0)
  542.   {
  543.      uiVoiceCnt--; //每次进入定时中断都自减1,直到等于零为止。才停止鸣叫
  544.      beep_dr=0;  //蜂鸣器是PNP三极管控制,低电平就开始鸣叫。
  545. //     beep_dr=1;  //蜂鸣器是PNP三极管控制,低电平就开始鸣叫。
  546.   }
  547.   else
  548.   {
  549.      ; //此处多加一个空指令,想维持跟if括号语句的数量对称,都是两条指令。不加也可以。
  550.      beep_dr=1;  //蜂鸣器是PNP三极管控制,高电平就停止鸣叫。
  551. //     beep_dr=0;  //蜂鸣器是PNP三极管控制,高电平就停止鸣叫。
  552.   }

  553.   display_drive();  //数码管字模的驱动函数


  554.   TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
  555.   TL0=0x0b;
  556.   TR0=1;  //开中断
  557. }


  558. void delay_short(unsigned int uiDelayShort)
  559. {
  560.    unsigned int i;  
  561.    for(i=0;i<uiDelayShort;i++)
  562.    {
  563.      ;   //一个分号相当于执行一条空语句
  564.    }
  565. }


  566. void delay_long(unsigned int uiDelayLong)
  567. {
  568.    unsigned int i;
  569.    unsigned int j;
  570.    for(i=0;i<uiDelayLong;i++)
  571.    {
  572.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  573.           {
  574.              ; //一个分号相当于执行一条空语句
  575.           }
  576.    }
  577. }


  578. void initial_myself()  //第一区 初始化单片机
  579. {

  580. /* 注释三:
  581. * 矩阵键盘也可以做独立按键,前提是把某一根公共输出线输出低电平,
  582. * 模拟独立按键的触发地,本程序中,把key_gnd_dr输出低电平。
  583. * 朱兆祺51学习板的S1就是本程序中用到的一个独立按键。
  584. */
  585.   key_gnd_dr=0; //模拟独立按键的地GND,因此必须一直输出低电平

  586.   led_dr=0;  //关闭独立LED灯
  587.   beep_dr=1; //用PNP三极管控制蜂鸣器,输出高电平时不叫。

  588.   hc595_drive(0x00,0x00);  //关闭所有经过另外两个74HC595驱动的LED灯

  589.   TMOD=0x01;  //设置定时器0为工作方式1

  590.   TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
  591.   TL0=0x0b;

  592. }

  593. void initial_peripheral() //第二区 初始化外围
  594. {


  595.    ucDigDot8=0;   //小数点全部不显示
  596.    ucDigDot7=0;  
  597.    ucDigDot6=0;
  598.    ucDigDot5=0;  
  599.    ucDigDot4=0;
  600.    ucDigDot3=0;  
  601.    ucDigDot2=0;
  602.    ucDigDot1=0;

  603.    uiSpeedCnt=440-(uiSetData1*2);  //速度档位越大,累计中断数uiSpeedCnt越小,从而倒计时的时间越快

  604.    EA=1;     //开总中断
  605.    ET0=1;    //允许定时中断
  606.    TR0=1;    //启动定时中断

  607. }
复制代码

总结陈词:
这节讲了能设置速度档位的数码管倒计时程序。现在很多人用iphone4S的手机,这个手机每次开机显示的时候,都要通过4个密码开锁,如果我们要用4位数码管来实现这个密码锁功能,该怎么编写这个程序?欲知详情,请听下回分解-----在数码管中实现iphone4S开机密码锁的程序。

(未完待续,下节更精彩,不要走开哦)
此帖出自51单片机论坛

回复

98

帖子

0

TA的资源

一粒金砂(高级)

第十九节:依次逐个点亮LED之后,再依次逐个熄灭LED的跑马灯程序。

开场白:
上一节讲了把74HC595驱动程序翻译成类似单片机IO口直接驱动的方式。这节在上一节的驱动程序基础上,开始讲跑马灯程序。我的跑马灯程序看似简单而且重复,其实蕴含着鸿哥的大智慧。它是基于鸿哥的switch状态机思想,领略到了它的简单和精髓,以后任何所谓复杂的工程项目,都不再复杂。要教会大家一个知识点:通过本跑马灯程序,加深理解鸿哥所有实战项目中switch状态机的思想精髓。
具体内容,请看源代码讲解。

(1)硬件平台:基于朱兆祺51单片机学习板。

(2)实现功能:第1个至第8个LED灯,先依次逐个亮,再依次逐个灭。第9至第16个LED灯一直灭。

(3)源代码讲解如下:
  1. #include "REG52.H"

  2. #define const_time_level_01_08  200  //第1个至第8个LED跑马灯的速度延时时间

  3. void initial_myself();   
  4. void initial_peripheral();
  5. void delay_short(unsigned int uiDelayShort);
  6. void delay_long(unsigned int uiDelaylong);
  7. void led_flicker_01_08(); // 第1个至第8个LED的跑马灯程序,逐个亮,逐个灭.
  8. void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01);
  9. void led_update();  //LED更新函数
  10. void T0_time();  //定时中断函数


  11. sbit hc595_sh_dr=P2^3;   
  12. sbit hc595_st_dr=P2^4;  
  13. sbit hc595_ds_dr=P2^5;  

  14. unsigned char ucLed_dr1=0;   //代表16个灯的亮灭状态,0代表灭,1代表亮
  15. unsigned char ucLed_dr2=0;
  16. unsigned char ucLed_dr3=0;
  17. unsigned char ucLed_dr4=0;
  18. unsigned char ucLed_dr5=0;
  19. unsigned char ucLed_dr6=0;
  20. unsigned char ucLed_dr7=0;
  21. unsigned char ucLed_dr8=0;
  22. unsigned char ucLed_dr9=0;
  23. unsigned char ucLed_dr10=0;
  24. unsigned char ucLed_dr11=0;
  25. unsigned char ucLed_dr12=0;
  26. unsigned char ucLed_dr13=0;
  27. unsigned char ucLed_dr14=0;
  28. unsigned char ucLed_dr15=0;
  29. unsigned char ucLed_dr16=0;

  30. unsigned char ucLed_update=0;  //刷新变量。每次更改LED灯的状态都要更新一次。

  31. unsigned char ucLedStep_01_08=0; //第1个至第8个LED跑马灯的步骤变量
  32. unsigned int  uiTimeCnt_01_08=0; //第1个至第8个LED跑马灯的统计定时中断次数的延时计数器

  33. unsigned char ucLedStatus16_09=0;   //代表底层74HC595输出状态的中间变量
  34. unsigned char ucLedStatus08_01=0;   //代表底层74HC595输出状态的中间变量

  35. void main()
  36.   {
  37.    initial_myself();  
  38.    delay_long(100);   
  39.    initial_peripheral();
  40.    while(1)   
  41.    {
  42.       led_flicker_01_08(); // 第1个至第8个LED的跑马灯程序,逐个亮,逐个灭.
  43.           led_update();  //LED更新函数
  44.    }

  45. }


  46. void led_update()  //LED更新函数
  47. {

  48.    if(ucLed_update==1)
  49.    {
  50.        ucLed_update=0;   //及时清零,让它产生只更新一次的效果,避免一直更新。

  51.        if(ucLed_dr1==1)
  52.            {
  53.               ucLedStatus08_01=ucLedStatus08_01|0x01;
  54.            }
  55.            else
  56.            {
  57.               ucLedStatus08_01=ucLedStatus08_01&0xfe;
  58.            }

  59.        if(ucLed_dr2==1)
  60.            {
  61.               ucLedStatus08_01=ucLedStatus08_01|0x02;
  62.            }
  63.            else
  64.            {
  65.               ucLedStatus08_01=ucLedStatus08_01&0xfd;
  66.            }

  67.        if(ucLed_dr3==1)
  68.            {
  69.               ucLedStatus08_01=ucLedStatus08_01|0x04;
  70.            }
  71.            else
  72.            {
  73.               ucLedStatus08_01=ucLedStatus08_01&0xfb;
  74.            }

  75.        if(ucLed_dr4==1)
  76.            {
  77.               ucLedStatus08_01=ucLedStatus08_01|0x08;
  78.            }
  79.            else
  80.            {
  81.               ucLedStatus08_01=ucLedStatus08_01&0xf7;
  82.            }


  83.        if(ucLed_dr5==1)
  84.            {
  85.               ucLedStatus08_01=ucLedStatus08_01|0x10;
  86.            }
  87.            else
  88.            {
  89.               ucLedStatus08_01=ucLedStatus08_01&0xef;
  90.            }


  91.        if(ucLed_dr6==1)
  92.            {
  93.               ucLedStatus08_01=ucLedStatus08_01|0x20;
  94.            }
  95.            else
  96.            {
  97.               ucLedStatus08_01=ucLedStatus08_01&0xdf;
  98.            }


  99.        if(ucLed_dr7==1)
  100.            {
  101.               ucLedStatus08_01=ucLedStatus08_01|0x40;
  102.            }
  103.            else
  104.            {
  105.               ucLedStatus08_01=ucLedStatus08_01&0xbf;
  106.            }


  107.        if(ucLed_dr8==1)
  108.            {
  109.               ucLedStatus08_01=ucLedStatus08_01|0x80;
  110.            }
  111.            else
  112.            {
  113.               ucLedStatus08_01=ucLedStatus08_01&0x7f;
  114.            }

  115.        if(ucLed_dr9==1)
  116.            {
  117.               ucLedStatus16_09=ucLedStatus16_09|0x01;
  118.            }
  119.            else
  120.            {
  121.               ucLedStatus16_09=ucLedStatus16_09&0xfe;
  122.            }

  123.        if(ucLed_dr10==1)
  124.            {
  125.               ucLedStatus16_09=ucLedStatus16_09|0x02;
  126.            }
  127.            else
  128.            {
  129.               ucLedStatus16_09=ucLedStatus16_09&0xfd;
  130.            }

  131.        if(ucLed_dr11==1)
  132.            {
  133.               ucLedStatus16_09=ucLedStatus16_09|0x04;
  134.            }
  135.            else
  136.            {
  137.               ucLedStatus16_09=ucLedStatus16_09&0xfb;
  138.            }

  139.        if(ucLed_dr12==1)
  140.            {
  141.               ucLedStatus16_09=ucLedStatus16_09|0x08;
  142.            }
  143.            else
  144.            {
  145.               ucLedStatus16_09=ucLedStatus16_09&0xf7;
  146.            }


  147.        if(ucLed_dr13==1)
  148.            {
  149.               ucLedStatus16_09=ucLedStatus16_09|0x10;
  150.            }
  151.            else
  152.            {
  153.               ucLedStatus16_09=ucLedStatus16_09&0xef;
  154.            }


  155.        if(ucLed_dr14==1)
  156.            {
  157.               ucLedStatus16_09=ucLedStatus16_09|0x20;
  158.            }
  159.            else
  160.            {
  161.               ucLedStatus16_09=ucLedStatus16_09&0xdf;
  162.            }


  163.        if(ucLed_dr15==1)
  164.            {
  165.               ucLedStatus16_09=ucLedStatus16_09|0x40;
  166.            }
  167.            else
  168.            {
  169.               ucLedStatus16_09=ucLedStatus16_09&0xbf;
  170.            }


  171.        if(ucLed_dr16==1)
  172.            {
  173.               ucLedStatus16_09=ucLedStatus16_09|0x80;
  174.            }
  175.            else
  176.            {
  177.               ucLedStatus16_09=ucLedStatus16_09&0x7f;
  178.            }

  179.        hc595_drive(ucLedStatus16_09,ucLedStatus08_01);  //74HC595底层驱动函数

  180.    }
  181. }

  182. void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01)
  183. {
  184.    unsigned char i;
  185.    unsigned char ucTempData;
  186.    hc595_sh_dr=0;
  187.    hc595_st_dr=0;

  188.    ucTempData=ucLedStatusTemp16_09;  //先送高8位
  189.    for(i=0;i<8;i++)
  190.    {
  191.          if(ucTempData>=0x80)hc595_ds_dr=1;
  192.          else hc595_ds_dr=0;

  193.          hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
  194.          delay_short(15);
  195.          hc595_sh_dr=1;
  196.          delay_short(15);

  197.          ucTempData=ucTempData<<1;
  198.    }

  199.    ucTempData=ucLedStatusTemp08_01;  //再先送低8位
  200.    for(i=0;i<8;i++)
  201.    {
  202.          if(ucTempData>=0x80)hc595_ds_dr=1;
  203.          else hc595_ds_dr=0;

  204.          hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
  205.          delay_short(15);
  206.          hc595_sh_dr=1;
  207.          delay_short(15);

  208.          ucTempData=ucTempData<<1;
  209.    }

  210.    hc595_st_dr=0;  //ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
  211.    delay_short(15);
  212.    hc595_st_dr=1;
  213.    delay_short(15);

  214.    hc595_sh_dr=0;    //拉低,抗干扰就增强
  215.    hc595_st_dr=0;
  216.    hc595_ds_dr=0;

  217. }

  218. /* 注释一:
  219. * 以下程序,看似简单而且重复,其实蕴含着鸿哥的大智慧。
  220. * 它是基于鸿哥的switch状态机思想,领略到了它的简单和精髓,
  221. * 以后任何所谓复杂的工程项目,都不再复杂。
  222. */
  223. void led_flicker_01_08() //第1个至第8个LED的跑马灯程序,逐个亮,逐个灭.
  224. {
  225.   switch(ucLedStep_01_08)
  226.   {
  227.      case 0:
  228.            if(uiTimeCnt_01_08>=const_time_level_01_08) //时间到
  229.            {
  230.                uiTimeCnt_01_08=0; //时间计数器清零

  231.                ucLed_dr1=1;  //第1个亮

  232.                ucLed_update=1;  //更新显示
  233.                ucLedStep_01_08=1; //切换到下一个步骤
  234.            }
  235.            break;
  236.      case 1:
  237.            if(uiTimeCnt_01_08>=const_time_level_01_08) //时间到
  238.            {
  239.                uiTimeCnt_01_08=0; //时间计数器清零

  240.                ucLed_dr2=1;  //第2个亮

  241.                ucLed_update=1;  //更新显示
  242.                ucLedStep_01_08=2; //切换到下一个步骤
  243.            }
  244.            break;
  245.      case 2:
  246.            if(uiTimeCnt_01_08>=const_time_level_01_08) //时间到
  247.            {
  248.                uiTimeCnt_01_08=0; //时间计数器清零

  249.                ucLed_dr3=1;  //第3个亮

  250.                ucLed_update=1;  //更新显示
  251.                ucLedStep_01_08=3; //切换到下一个步骤
  252.            }
  253.            break;
  254.      case 3:
  255.            if(uiTimeCnt_01_08>=const_time_level_01_08) //时间到
  256.            {
  257.                uiTimeCnt_01_08=0; //时间计数器清零

  258.                ucLed_dr4=1;  //第4个亮

  259.                ucLed_update=1;  //更新显示
  260.                ucLedStep_01_08=4; //切换到下一个步骤
  261.            }
  262.            break;
  263.      case 4:
  264.            if(uiTimeCnt_01_08>=const_time_level_01_08) //时间到
  265.            {
  266.                uiTimeCnt_01_08=0; //时间计数器清零

  267.                ucLed_dr5=1;  //第5个亮

  268.                ucLed_update=1;  //更新显示
  269.                ucLedStep_01_08=5; //切换到下一个步骤
  270.            }
  271.            break;
  272.      case 5:
  273.            if(uiTimeCnt_01_08>=const_time_level_01_08) //时间到
  274.            {
  275.                uiTimeCnt_01_08=0; //时间计数器清零

  276.                ucLed_dr6=1;  //第6个亮

  277.                ucLed_update=1;  //更新显示
  278.                ucLedStep_01_08=6; //切换到下一个步骤
  279.            }
  280.            break;
  281.      case 6:
  282.            if(uiTimeCnt_01_08>=const_time_level_01_08) //时间到
  283.            {
  284.                uiTimeCnt_01_08=0; //时间计数器清零

  285.                ucLed_dr7=1;  //第7个亮

  286.                ucLed_update=1;  //更新显示
  287.                ucLedStep_01_08=7; //切换到下一个步骤
  288.            }
  289.            break;
  290.      case 7:
  291.            if(uiTimeCnt_01_08>=const_time_level_01_08) //时间到
  292.            {
  293.                uiTimeCnt_01_08=0; //时间计数器清零

  294.                ucLed_dr8=1;  //第8个亮

  295.                ucLed_update=1;  //更新显示
  296.                ucLedStep_01_08=8; //切换到下一个步骤
  297.            }
  298.            break;
  299.      case 8:
  300.            if(uiTimeCnt_01_08>=const_time_level_01_08) //时间到
  301.            {
  302.                uiTimeCnt_01_08=0; //时间计数器清零

  303.                ucLed_dr8=0;  //第8个灭

  304.                ucLed_update=1;  //更新显示
  305.                ucLedStep_01_08=9; //切换到下一个步骤
  306.            }
  307.            break;
  308.      case 9:
  309.            if(uiTimeCnt_01_08>=const_time_level_01_08) //时间到
  310.            {
  311.                uiTimeCnt_01_08=0; //时间计数器清零

  312.                ucLed_dr7=0;  //第7个灭

  313.                ucLed_update=1;  //更新显示
  314.                ucLedStep_01_08=10; //切换到下一个步骤
  315.            }
  316.            break;
  317.      case 10:
  318.            if(uiTimeCnt_01_08>=const_time_level_01_08) //时间到
  319.            {
  320.                uiTimeCnt_01_08=0; //时间计数器清零

  321.                ucLed_dr6=0;  //第6个灭

  322.                ucLed_update=1;  //更新显示
  323.                ucLedStep_01_08=11; //切换到下一个步骤
  324.            }
  325.            break;
  326.      case 11:
  327.            if(uiTimeCnt_01_08>=const_time_level_01_08) //时间到
  328.            {
  329.                uiTimeCnt_01_08=0; //时间计数器清零

  330.                ucLed_dr5=0;  //第5个灭

  331.                ucLed_update=1;  //更新显示
  332.                ucLedStep_01_08=12; //切换到下一个步骤
  333.            }
  334.            break;
  335.      case 12:
  336.            if(uiTimeCnt_01_08>=const_time_level_01_08) //时间到
  337.            {
  338.                uiTimeCnt_01_08=0; //时间计数器清零

  339.                ucLed_dr4=0;  //第4个灭

  340.                ucLed_update=1;  //更新显示
  341.                ucLedStep_01_08=13; //切换到下一个步骤
  342.            }
  343.            break;
  344.      case 13:
  345.            if(uiTimeCnt_01_08>=const_time_level_01_08) //时间到
  346.            {
  347.                uiTimeCnt_01_08=0; //时间计数器清零

  348.                ucLed_dr3=0;  //第3个灭

  349.                ucLed_update=1;  //更新显示
  350.                ucLedStep_01_08=14; //切换到下一个步骤
  351.            }
  352.            break;
  353.      case 14:
  354.            if(uiTimeCnt_01_08>=const_time_level_01_08) //时间到
  355.            {
  356.                uiTimeCnt_01_08=0; //时间计数器清零

  357.                ucLed_dr2=0;  //第2个灭

  358.                ucLed_update=1;  //更新显示
  359.                ucLedStep_01_08=15; //切换到下一个步骤
  360.            }
  361.            break;
  362.      case 15:
  363.            if(uiTimeCnt_01_08>=const_time_level_01_08) //时间到
  364.            {
  365.                uiTimeCnt_01_08=0; //时间计数器清零

  366.                ucLed_dr1=0;  //第1个灭

  367.                ucLed_update=1;  //更新显示
  368.                ucLedStep_01_08=0; //返回到最开始处,重新开始新的一次循环。
  369.            }
  370.            break;

  371.    }

  372. }


  373. void T0_time() interrupt 1
  374. {
  375.   TF0=0;  //清除中断标志
  376.   TR0=0; //关中断

  377.   if(uiTimeCnt_01_08<0xffff)  //设定这个条件,防止uiTimeCnt超范围。
  378.   {
  379.       uiTimeCnt_01_08++;  //累加定时中断的次数,
  380.   }

  381.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  382.   TL0=0x2f;
  383.   TR0=1;  //开中断
  384. }

  385. void delay_short(unsigned int uiDelayShort)
  386. {
  387.    unsigned int i;  
  388.    for(i=0;i<uiDelayShort;i++)
  389.    {
  390.      ;   //一个分号相当于执行一条空语句
  391.    }
  392. }

  393. void delay_long(unsigned int uiDelayLong)
  394. {
  395.    unsigned int i;
  396.    unsigned int j;
  397.    for(i=0;i<uiDelayLong;i++)
  398.    {
  399.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  400.           {
  401.              ; //一个分号相当于执行一条空语句
  402.           }
  403.    }
  404. }


  405. void initial_myself()  //第一区 初始化单片机
  406. {

  407.   TMOD=0x01;  //设置定时器0为工作方式1


  408.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  409.   TL0=0x2f;


  410. }

  411. void initial_peripheral() //第二区 初始化外围
  412. {
  413.   EA=1;     //开总中断
  414.   ET0=1;    //允许定时中断
  415.   TR0=1;    //启动定时中断

  416. }
复制代码


总结陈词:
这节讲了在第1个至第8个LED灯中,先依次逐个亮再依次逐个灭的跑马灯程序。下一节我们略作修改,继续做跑马灯的程序,要求在第9个至第16个LED灯中,依次逐个亮灯并且每次只能亮一个灯(其它的都灭),依次循环,我们该如何编写程序?欲知详情,请听下回分解-----依次逐个亮灯并且每次只能亮一个灯的跑马灯程序。
此帖出自51单片机论坛

回复

98

帖子

0

TA的资源

一粒金砂(高级)

第十八节:把74HC595驱动程序翻译成类似单片机IO口直接驱动的方式。

开场白:
上一节讲了74HC595的驱动程序。为了更加方便操作74HC595输出的每个IO状态,这节讲如何把74HC595驱动程序翻译成类似单片机IO口直接驱动的方式。要教会大家两个知识点:
第一点:如何灵活运用与和非的运算符来实现位的操作。
第二点:如何灵活运用一个更新变量来实现静态刷新输出或者静态刷新显示的功能。
具体内容,请看源代码讲解。

(1)硬件平台:基于朱兆祺51单片机学习板。

(2)实现功能:两片联级的74HC595驱动的16个LED灯交叉闪烁。比如,先是第1,3,5,7,9,11,13,15八个灯亮,其它的灯都灭。然后再反过来,原来亮的就灭,原来灭的就亮。交替闪烁。

(3)源代码讲解如下:
  1. #include "REG52.H"

  2. #define const_time_level 200  

  3. void initial_myself();   
  4. void initial_peripheral();
  5. void delay_short(unsigned int uiDelayShort);
  6. void delay_long(unsigned int uiDelaylong);
  7. void led_flicker();
  8. void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01);
  9. void led_update();  //LED更新函数
  10. void T0_time();  //定时中断函数


  11. sbit hc595_sh_dr=P2^3;   
  12. sbit hc595_st_dr=P2^4;  
  13. sbit hc595_ds_dr=P2^5;  

  14. unsigned char ucLed_dr1=0;   //代表16个灯的亮灭状态,0代表灭,1代表亮
  15. unsigned char ucLed_dr2=0;
  16. unsigned char ucLed_dr3=0;
  17. unsigned char ucLed_dr4=0;
  18. unsigned char ucLed_dr5=0;
  19. unsigned char ucLed_dr6=0;
  20. unsigned char ucLed_dr7=0;
  21. unsigned char ucLed_dr8=0;
  22. unsigned char ucLed_dr9=0;
  23. unsigned char ucLed_dr10=0;
  24. unsigned char ucLed_dr11=0;
  25. unsigned char ucLed_dr12=0;
  26. unsigned char ucLed_dr13=0;
  27. unsigned char ucLed_dr14=0;
  28. unsigned char ucLed_dr15=0;
  29. unsigned char ucLed_dr16=0;

  30. unsigned char ucLed_update=0;  //刷新变量。每次更改LED灯的状态都要更新一次。

  31. unsigned char ucLedStep=0; //步骤变量
  32. unsigned int  uiTimeCnt=0; //统计定时中断次数的延时计数器

  33. unsigned char ucLedStatus16_09=0;   //代表底层74HC595输出状态的中间变量
  34. unsigned char ucLedStatus08_01=0;   //代表底层74HC595输出状态的中间变量

  35. void main()
  36.   {
  37.    initial_myself();  
  38.    delay_long(100);   
  39.    initial_peripheral();
  40.    while(1)   
  41.    {
  42.       led_flicker();   
  43.           led_update();  //LED更新函数
  44.    }

  45. }


  46. /* 注释一:
  47. * 把74HC595驱动程序翻译成类似单片机IO口直接驱动方式的过程。
  48. * 每次更新LED输出,记得都要把ucLed_update置1表示更新。
  49. */
  50. void led_update()  //LED更新函数
  51. {

  52.    if(ucLed_update==1)
  53.    {
  54.        ucLed_update=0;   //及时清零,让它产生只更新一次的效果,避免一直更新。

  55.        if(ucLed_dr1==1)
  56.            {
  57.               ucLedStatus08_01=ucLedStatus08_01|0x01;
  58.            }
  59.            else
  60.            {
  61.               ucLedStatus08_01=ucLedStatus08_01&0xfe;
  62.            }

  63.        if(ucLed_dr2==1)
  64.            {
  65.               ucLedStatus08_01=ucLedStatus08_01|0x02;
  66.            }
  67.            else
  68.            {
  69.               ucLedStatus08_01=ucLedStatus08_01&0xfd;
  70.            }

  71.        if(ucLed_dr3==1)
  72.            {
  73.               ucLedStatus08_01=ucLedStatus08_01|0x04;
  74.            }
  75.            else
  76.            {
  77.               ucLedStatus08_01=ucLedStatus08_01&0xfb;
  78.            }

  79.        if(ucLed_dr4==1)
  80.            {
  81.               ucLedStatus08_01=ucLedStatus08_01|0x08;
  82.            }
  83.            else
  84.            {
  85.               ucLedStatus08_01=ucLedStatus08_01&0xf7;
  86.            }


  87.        if(ucLed_dr5==1)
  88.            {
  89.               ucLedStatus08_01=ucLedStatus08_01|0x10;
  90.            }
  91.            else
  92.            {
  93.               ucLedStatus08_01=ucLedStatus08_01&0xef;
  94.            }


  95.        if(ucLed_dr6==1)
  96.            {
  97.               ucLedStatus08_01=ucLedStatus08_01|0x20;
  98.            }
  99.            else
  100.            {
  101.               ucLedStatus08_01=ucLedStatus08_01&0xdf;
  102.            }


  103.        if(ucLed_dr7==1)
  104.            {
  105.               ucLedStatus08_01=ucLedStatus08_01|0x40;
  106.            }
  107.            else
  108.            {
  109.               ucLedStatus08_01=ucLedStatus08_01&0xbf;
  110.            }


  111.        if(ucLed_dr8==1)
  112.            {
  113.               ucLedStatus08_01=ucLedStatus08_01|0x80;
  114.            }
  115.            else
  116.            {
  117.               ucLedStatus08_01=ucLedStatus08_01&0x7f;
  118.            }

  119.        if(ucLed_dr9==1)
  120.            {
  121.               ucLedStatus16_09=ucLedStatus16_09|0x01;
  122.            }
  123.            else
  124.            {
  125.               ucLedStatus16_09=ucLedStatus16_09&0xfe;
  126.            }

  127.        if(ucLed_dr10==1)
  128.            {
  129.               ucLedStatus16_09=ucLedStatus16_09|0x02;
  130.            }
  131.            else
  132.            {
  133.               ucLedStatus16_09=ucLedStatus16_09&0xfd;
  134.            }

  135.        if(ucLed_dr11==1)
  136.            {
  137.               ucLedStatus16_09=ucLedStatus16_09|0x04;
  138.            }
  139.            else
  140.            {
  141.               ucLedStatus16_09=ucLedStatus16_09&0xfb;
  142.            }

  143.        if(ucLed_dr12==1)
  144.            {
  145.               ucLedStatus16_09=ucLedStatus16_09|0x08;
  146.            }
  147.            else
  148.            {
  149.               ucLedStatus16_09=ucLedStatus16_09&0xf7;
  150.            }


  151.        if(ucLed_dr13==1)
  152.            {
  153.               ucLedStatus16_09=ucLedStatus16_09|0x10;
  154.            }
  155.            else
  156.            {
  157.               ucLedStatus16_09=ucLedStatus16_09&0xef;
  158.            }


  159.        if(ucLed_dr14==1)
  160.            {
  161.               ucLedStatus16_09=ucLedStatus16_09|0x20;
  162.            }
  163.            else
  164.            {
  165.               ucLedStatus16_09=ucLedStatus16_09&0xdf;
  166.            }


  167.        if(ucLed_dr15==1)
  168.            {
  169.               ucLedStatus16_09=ucLedStatus16_09|0x40;
  170.            }
  171.            else
  172.            {
  173.               ucLedStatus16_09=ucLedStatus16_09&0xbf;
  174.            }


  175.        if(ucLed_dr16==1)
  176.            {
  177.               ucLedStatus16_09=ucLedStatus16_09|0x80;
  178.            }
  179.            else
  180.            {
  181.               ucLedStatus16_09=ucLedStatus16_09&0x7f;
  182.            }

  183.        hc595_drive(ucLedStatus16_09,ucLedStatus08_01);  //74HC595底层驱动函数

  184.    }
  185. }

  186. void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01)
  187. {
  188.    unsigned char i;
  189.    unsigned char ucTempData;
  190.    hc595_sh_dr=0;
  191.    hc595_st_dr=0;

  192.    ucTempData=ucLedStatusTemp16_09;  //先送高8位
  193.    for(i=0;i<8;i++)
  194.    {
  195.          if(ucTempData>=0x80)hc595_ds_dr=1;
  196.          else hc595_ds_dr=0;

  197.          hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
  198.          delay_short(15);
  199.          hc595_sh_dr=1;
  200.          delay_short(15);

  201.          ucTempData=ucTempData<<1;
  202.    }

  203.    ucTempData=ucLedStatusTemp08_01;  //再先送低8位
  204.    for(i=0;i<8;i++)
  205.    {
  206.          if(ucTempData>=0x80)hc595_ds_dr=1;
  207.          else hc595_ds_dr=0;

  208.          hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
  209.          delay_short(15);
  210.          hc595_sh_dr=1;
  211.          delay_short(15);

  212.          ucTempData=ucTempData<<1;
  213.    }

  214.    hc595_st_dr=0;  //ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
  215.    delay_short(15);
  216.    hc595_st_dr=1;
  217.    delay_short(15);

  218.    hc595_sh_dr=0;    //拉低,抗干扰就增强
  219.    hc595_st_dr=0;
  220.    hc595_ds_dr=0;

  221. }


  222. void led_flicker() ////第三区 LED闪烁应用程序
  223. {
  224.   switch(ucLedStep)
  225.   {
  226.      case 0:
  227.            if(uiTimeCnt>=const_time_level) //时间到
  228.            {
  229.                uiTimeCnt=0; //时间计数器清零

  230.                ucLed_dr1=1;  //每个变量都代表一个LED灯的状态
  231.                ucLed_dr2=0;
  232.                ucLed_dr3=1;
  233.                ucLed_dr4=0;
  234.                ucLed_dr5=1;
  235.                ucLed_dr6=0;
  236.                ucLed_dr7=1;
  237.                ucLed_dr8=0;
  238.                ucLed_dr9=1;
  239.                ucLed_dr10=0;
  240.                ucLed_dr11=1;
  241.                ucLed_dr12=0;
  242.                ucLed_dr13=1;
  243.                ucLed_dr14=0;
  244.                ucLed_dr15=1;
  245.                ucLed_dr16=0;

  246.                ucLed_update=1;  //更新显示
  247.                ucLedStep=1; //切换到下一个步骤
  248.            }
  249.            break;
  250.      case 1:
  251.            if(uiTimeCnt>=const_time_level) //时间到
  252.            {
  253.                uiTimeCnt=0; //时间计数器清零

  254.                ucLed_dr1=0;  //每个变量都代表一个LED灯的状态
  255.                ucLed_dr2=1;
  256.                ucLed_dr3=0;
  257.                ucLed_dr4=1;
  258.                ucLed_dr5=0;
  259.                ucLed_dr6=1;
  260.                ucLed_dr7=0;
  261.                ucLed_dr8=1;
  262.                ucLed_dr9=0;
  263.                ucLed_dr10=1;
  264.                ucLed_dr11=0;
  265.                ucLed_dr12=1;
  266.                ucLed_dr13=0;
  267.                ucLed_dr14=1;
  268.                ucLed_dr15=0;
  269.                ucLed_dr16=1;

  270.                ucLed_update=1;  //更新显示
  271.                ucLedStep=0; //返回到上一个步骤
  272.            }
  273.            break;
  274.   
  275.    }

  276. }


  277. void T0_time() interrupt 1
  278. {
  279.   TF0=0;  //清除中断标志
  280.   TR0=0; //关中断

  281.   if(uiTimeCnt<0xffff)  //设定这个条件,防止uiTimeCnt超范围。
  282.   {
  283.       uiTimeCnt++;  //累加定时中断的次数,
  284.   }

  285.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  286.   TL0=0x2f;
  287.   TR0=1;  //开中断
  288. }

  289. void delay_short(unsigned int uiDelayShort)
  290. {
  291.    unsigned int i;  
  292.    for(i=0;i<uiDelayShort;i++)
  293.    {
  294.      ;   //一个分号相当于执行一条空语句
  295.    }
  296. }

  297. void delay_long(unsigned int uiDelayLong)
  298. {
  299.    unsigned int i;
  300.    unsigned int j;
  301.    for(i=0;i<uiDelayLong;i++)
  302.    {
  303.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  304.           {
  305.              ; //一个分号相当于执行一条空语句
  306.           }
  307.    }
  308. }


  309. void initial_myself()  //第一区 初始化单片机
  310. {

  311.   TMOD=0x01;  //设置定时器0为工作方式1


  312.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  313.   TL0=0x2f;


  314. }

  315. void initial_peripheral() //第二区 初始化外围
  316. {
  317.   EA=1;     //开总中断
  318.   ET0=1;    //允许定时中断
  319.   TR0=1;    //启动定时中断

  320. }
复制代码

总结陈词:
这节讲了把74HC595驱动程序翻译成类似单片机IO口直接驱动的方式,接下来,我们该如何来运用这种驱动方式实现跑马灯的程序?欲知详情,请听下回分解-----依次逐个点亮LED之后,再依次逐个熄灭LED的跑马灯程序。

(未完待续,下节更精彩,不要走开哦)
此帖出自51单片机论坛

回复

98

帖子

0

TA的资源

一粒金砂(高级)

第十七节:两片联级74HC595驱动16个LED灯的基本驱动程序。

开场白:
上一节讲了如何把矩阵键盘翻译成独立按键的处理方式。这节讲74HC595的驱动程序。要教会大家两个知识点:
第一点:朱兆祺的学习板是用74HC595控制LED,因此可以直接把595的OE引脚接地。如果在工控中,用来控制继电器,那么此芯片的片选脚OE不要为了省一个IO口而直接接地,否则会引起上电瞬间继电器莫名其妙地动作。为了解决这个问题,OE脚应该用一个IO口单独驱动,并且千万要记住,此IO必须接一个15K左右的上拉电阻,然后在程序刚上电运行时,先把OE置高,并且尽快把所有的74HC595输出口置低,然后再把OE置低.当然还有另外一种解决办法,就是用一个10uF的电解电容跟一个100K的下拉电阻,组成跟51单片机外围复位电路原理一样的电路,连接到OE口,这样确保上电瞬间OE口有一小段时间是处于高电平状态,在此期间,尽快通过软件把74hc595的所有输出口置低。
第二点:两个联级74HC595的工作过程:每个74HC595内部都有一个8位的寄存器,两个联级起来就有两个寄存器。ST引脚就相当于一个刷新信号引脚,当ST引脚产生一个上升沿信号时,就会把寄存器的数值输出到74HC595的输出引脚并且锁存起来,DS是数据引脚,SH是把新数据送入寄存器的时钟信号。也就是说,SH引脚负责把数据送入到寄存器里,ST引脚负责把寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来。

具体内容,请看源代码讲解。

(1)硬件平台:基于朱兆祺51单片机学习板。

(2)实现功能:两片联级的74HC595驱动的16个LED灯交叉闪烁。比如,先是第1,3,5,7,9,11,13,15八个灯亮,其它的灯都灭。然后再反过来,原来亮的就灭,原来灭的就亮。交替闪烁。

(3)源代码讲解如下:
  1. #include "REG52.H"

  2. #define const_time_level 200  

  3. void initial_myself();   
  4. void initial_peripheral();
  5. void delay_short(unsigned int uiDelayShort);
  6. void delay_long(unsigned int uiDelaylong);
  7. void led_flicker();
  8. void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01);
  9. void T0_time();  //定时中断函数

  10. /* 注释一:
  11. * 朱兆祺的学习板是用74HC595控制LED,因此可以直接把595的OE引脚接地。如果在工控中,用来控制继电器,
  12. * 那么此芯片的片选脚OE不要为了省一个IO口而直接接地,否则会引起上电瞬间继电器莫名其妙地动作。
  13. * 为了解决这个问题,OE脚应该用一个IO口单独驱动,并且千万要记住,此IO必须接一个15K左右的
  14. * 上拉电阻,然后在程序刚上电运行时,先把OE置高,并且尽快把所有的74HC595输出口置低,然后再把OE置低.
  15. * 当然还有另外一种解决办法,就是用一个10uF的电解电容跟一个100K的下拉电阻,组成跟51单片机外围复位电路原理
  16. * 一样的电路,连接到OE口,这样确保上电瞬间OE口有一小段时间是处于高电平状态,在此 期间,
  17. * 尽快通过软件把74hc595的所有输出口置低。
  18. */
  19. sbit hc595_sh_dr=P2^3;   
  20. sbit hc595_st_dr=P2^4;  
  21. sbit hc595_ds_dr=P2^5;  


  22. unsigned char ucLedStep=0; //步骤变量
  23. unsigned int  uiTimeCnt=0; //统计定时中断次数的延时计数器


  24. void main()
  25.   {
  26.    initial_myself();  
  27.    delay_long(100);   
  28.    initial_peripheral();
  29.    while(1)   
  30.    {
  31.       led_flicker();   
  32.    }

  33. }

  34. /* 注释二:
  35. * 两个联级74HC595的工作过程:
  36. * 每个74HC595内部都有一个8位的寄存器,两个联级起来就有两个寄存器。ST引脚就相当于一个刷新
  37. * 信号引脚,当ST引脚产生一个上升沿信号时,就会把寄存器的数值输出到74HC595的输出引脚并且锁存起来,
  38. * DS是数据引脚,SH是把新数据送入寄存器的时钟信号。也就是说,SH引脚负责把数据送入到寄存器里,ST引脚
  39. * 负责把寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来。
  40. */
  41. void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01)
  42. {
  43.    unsigned char i;
  44.    unsigned char ucTempData;
  45.    hc595_sh_dr=0;
  46.    hc595_st_dr=0;

  47.    ucTempData=ucLedStatusTemp16_09;  //先送高8位
  48.    for(i=0;i<8;i++)
  49.    {
  50.          if(ucTempData>=0x80)hc595_ds_dr=1;
  51.          else hc595_ds_dr=0;

  52.          hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
  53.          delay_short(15);
  54.          hc595_sh_dr=1;
  55.          delay_short(15);

  56.          ucTempData=ucTempData<<1;
  57.    }

  58.    ucTempData=ucLedStatusTemp08_01;  //再先送低8位
  59.    for(i=0;i<8;i++)
  60.    {
  61.          if(ucTempData>=0x80)hc595_ds_dr=1;
  62.          else hc595_ds_dr=0;

  63.          hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
  64.          delay_short(15);
  65.          hc595_sh_dr=1;
  66.          delay_short(15);

  67.          ucTempData=ucTempData<<1;
  68.    }

  69.    hc595_st_dr=0;  //ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
  70.    delay_short(15);
  71.    hc595_st_dr=1;
  72.    delay_short(15);

  73.    hc595_sh_dr=0;    //拉低,抗干扰就增强
  74.    hc595_st_dr=0;
  75.    hc595_ds_dr=0;

  76. }


  77. void led_flicker() ////第三区 LED闪烁应用程序
  78. {
  79.   switch(ucLedStep)
  80.   {
  81.      case 0:
  82.            if(uiTimeCnt>=const_time_level) //时间到
  83.            {
  84.                uiTimeCnt=0; //时间计数器清零
  85.                hc595_drive(0x55,0x55);
  86.                ucLedStep=1; //切换到下一个步骤
  87.            }
  88.            break;
  89.      case 1:
  90.            if(uiTimeCnt>=const_time_level) //时间到
  91.            {
  92.                uiTimeCnt=0; //时间计数器清零
  93.                hc595_drive(0xaa,0xaa);
  94.                ucLedStep=0; //返回到上一个步骤
  95.            }
  96.            break;
  97.   
  98.    }

  99. }


  100. void T0_time() interrupt 1
  101. {
  102.   TF0=0;  //清除中断标志
  103.   TR0=0; //关中断

  104.   if(uiTimeCnt<0xffff)  //设定这个条件,防止uiTimeCnt超范围。
  105.   {
  106.       uiTimeCnt++;  //累加定时中断的次数,
  107.   }

  108.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  109.   TL0=0x2f;
  110.   TR0=1;  //开中断
  111. }

  112. void delay_short(unsigned int uiDelayShort)
  113. {
  114.    unsigned int i;  
  115.    for(i=0;i<uiDelayShort;i++)
  116.    {
  117.      ;   //一个分号相当于执行一条空语句
  118.    }
  119. }

  120. void delay_long(unsigned int uiDelayLong)
  121. {
  122.    unsigned int i;
  123.    unsigned int j;
  124.    for(i=0;i<uiDelayLong;i++)
  125.    {
  126.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  127.           {
  128.              ; //一个分号相当于执行一条空语句
  129.           }
  130.    }
  131. }


  132. void initial_myself()  //第一区 初始化单片机
  133. {

  134.   TMOD=0x01;  //设置定时器0为工作方式1


  135.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  136.   TL0=0x2f;


  137. }

  138. void initial_peripheral() //第二区 初始化外围
  139. {
  140.   EA=1;     //开总中断
  141.   ET0=1;    //允许定时中断
  142.   TR0=1;    //启动定时中断

  143. }
复制代码

总结陈词:
这节讲了74HC595的驱动程序,它是一次控制16个LED同时亮灭的,在实际中应用不太方便,如果我们想要像单片机IO口直接控制LED那样方便,我们该怎么编写程序呢?欲知详情,请听下回分解-----把74HC595驱动程序翻译成类似单片机IO口直接驱动的方式。
(未完待续,下节更精彩,不要走开哦)
此帖出自51单片机论坛

回复

98

帖子

0

TA的资源

一粒金砂(高级)

第一节:吴坚鸿谈初学单片机的误区。

(1)很难记住繁杂的寄存器?寄存器不用死记硬背,鸿哥我行走江湖多年,连一个寄存器都记不住。需要配置寄存器的时候,直接在网上或者书本上参考别人现成的配置程序是上策,查找芯片数据手册是中策,死记硬背寄存器是最最下策。

(2)很难记住繁杂的汇编语言指令?除非是在校学生要应付考试或者少数工作中绕不开汇编,否则学汇编就是浪费时间。鸿哥我行走江湖多年,从来就没有用汇编帮客户做过一个项目。

(3)C语言很难学?你不用学指针,你不用学带形参的函数,你不用学结构体,你不用学宏定义,你不用学文件操作,你也不用死记繁琐的数据类型。你只要会:
      5条指令语句switch语句,if else语句,while语句,for语句,=赋值语句。
      7个运算符+,-,*,/,|,&,!。
      4个逻辑关系符||,&&,!=,==.
      3个数据类型unsigned char, unsigned int, unsigned long。
      3个进制相互转化,二进制,十六进制,十进制。
      1个void函数。            
      1个一维数组code(或const) unsigned char array[]。
      那么世界上任何一种逻辑功能的单片机软件你都能做出来。
      鸿哥我当年刚毕业出来工作的时候才知道可以用C语言开发单片机,一开始只用if语句就把项目做出来了,没有用指针,没有用带形参的函数等复杂的功能。再到后来才慢慢开始用C语言其他的高级功能,但是我发现C语言其他的高级功能,本质上都是用我前面列举出来的最基本功能集合而成,只是书写更加简单方便了一点,编译后的机器码都大同小异。所以不会指针等高级功能你不用自卑,恰恰相反,当你会最简单的几个语句,就把这些高级功能的程序都做出来了,你才发现你对底层了解得更加透切,再学那些高级功能轻而易举。当你裸机跑的程序都能够协调得很好的时候,你才发现所谓高深的操作系统也不过如此,只要给你时间和金钱你也可以写个操作系统来玩玩。

(4)很难记住精确时间的计算公式?经常看到时间公式等于晶振,时钟周期,执行指令次数他们之间的乘除关系式。鸿哥我认为这些都是浮云,不用纠结也不用去记,大概了解一下就可以了。不管你对公式掌握得有多精确,你都不可能做出非常精确的时间。想用单片机做一个非常精确的时间这种想法一开始就是错的,不可能的。真想做一个比较精确的时间,应该用外围时钟芯片或者FPGA和CPLD,而不是单片机。

(5)很难记住繁杂的各种通信协议?什么IIC,SPI,232串口通讯,CAN,USB等等。这些都是浮云,你不用记那么多,你只要理解两种通讯方式就够了,那就是串行通讯方式和并行通讯方式。不管世界上有多少种通讯协议,物理世界上只有这两种通讯方式,其他各种名称的通讯协议都基于此两种方式演变而来。

(6)很难写短小精悍的程序?初学者不要纠结于此。做项目开发,程序容量不是刻意追求的目标,程序多一点少一点没关系,现在大容量的单片机品种非常多,容量不会是寸土寸金的事情,我们更加要关注程序的运行效率,可读性和可修改性。

      既然鸿哥列出了那么多误区,那么什么才是初学者关注的核心?预知详情,请听下回分解----delay()延时实现LED灯的闪烁。

(未完待续,下节更精彩,不要走开哦)
此帖出自51单片机论坛

回复

98

帖子

0

TA的资源

一粒金砂(高级)

第四节:累计定时中断次数使LED灯闪烁。

开场白:
上一节提到在累计主循环次数来实现计时,随着主函数里任务量的增加,为了保证延时时间的准确性,要不断修正设定上限阀值const_time_level 。我们该怎么解决这个问题呢?本节教大家利用累计定时中断次数的方法来解决这个问题。这一节要教会大家四个知识点:
第一点:利用累计定时中断次数的方法实现时间延时
第二点:展现鸿哥最完整的实战程序框架。在主函数循环里用switch语句实现状态机的切换,在定时中断里累计中断次数,这两个的结合就是我写代码最本质的框架思想。
第三点:提醒大家C语言中的int ,long变量是由几个字节构成的数据,凡是在main函数和中断函数里有可能同时改变的变量,这个变量应该在主函数中被更改之前,先关闭相应的中断,更改完了此变量,再打开中断,否则会留下不宜察觉的漏洞。当然在大部分的项目中可以不用这么操作,但是在一些要求非常高的项目中,有一些核心变量必须这么做。
第四点:定时中断的初始值该怎么设置。不用严格按公式来计算时间,一般取个经验值是最大初始值减去1000就可以了。
具体内容,请看源代码讲解。

(1)硬件平台:基于朱兆祺51单片机学习板。

(2)实现功能:让一个LED闪烁。

(3)源代码讲解如下:
  1. #include "REG52.H"

  2. #define const_time_level 200  

  3. void initial_myself();   
  4. void initial_peripheral();
  5. void delay_long(unsigned int uiDelaylong);
  6. void led_flicker();
  7. void T0_time();  //定时中断函数

  8. sbit led_dr=P3^5;  

  9. unsigned char ucLedStep=0; //步骤变量
  10. unsigned int  uiTimeCnt=0; //统计定时中断次数的延时计数器


  11. void main()
  12.   {
  13.    initial_myself();  
  14.    delay_long(100);   
  15.    initial_peripheral();
  16.    while(1)   
  17.    {
  18.       led_flicker();   
  19.    }

  20. }

  21. void led_flicker() ////第三区 LED闪烁应用程序
  22. {
  23.   
  24.   switch(ucLedStep)
  25.   {
  26.      case 0:
  27. /* 注释一:
  28. * uiTimeCnt累加定时中断的次数,每一次定时中断它都会在中断函数里自加一。
  29. * 只有当它的次数大于或等于设定上限const_time_level时,
  30. * 才会去改变LED灯的状态,否则CPU退出led_flicker()任务,继续快速扫描其他的任务,
  31. * 这样的程序结构就可以达到多任务并行处理的目的。这就是鸿哥在所有开发项目中的核心框架。
  32. */
  33.                   if(uiTimeCnt>=const_time_level) //时间到
  34.                   {

  35. /* 注释二:
  36. * ET0=0;uiTimeCnt=0;ET0=1;----在清零uiTimeCnt之前,为什么要先禁止定时中断?
  37. * 因为uiTimeCnt是unsigned int类型,本质上是由两个字节组成。
  38. * 在C语言中uiTimeCnt=0看似一条指令,实际上经过编译之后它不只一条汇编指令。
  39. * 由于定时中断函数里也对这个变量进行累加操作,如果不禁止定时中断,
  40. * 那么uiTimeCnt这个变量在main()函数中还没被完全清零的时候,如果这个时候
  41. * 突然来一个定时中断,并且在中断里又更改了此变量,这种情况在某些要求高的
  42. * 项目上会是一个不容易察觉的漏洞,为项目带来隐患。当然,大部分的普通项目,
  43. * 都可以不用那么严格,可以不用禁止定时中断。在这里只是提醒各位初学者有这种情况。
  44. */
  45.              ET0=0;  //禁止定时中断
  46.                      uiTimeCnt=0; //时间计数器清零
  47.              ET0=1; //开启定时中断
  48.              led_dr=1;    //让LED亮
  49.                          ucLedStep=1; //切换到下一个步骤
  50.                   }
  51.               break;
  52.      case 1:
  53.                   if(uiTimeCnt>=const_time_level) //时间到
  54.                   {
  55.              ET0=0;  //禁止定时中断
  56.                      uiTimeCnt=0; //时间计数器清零
  57.              ET0=1;   //开启定时中断
  58.              led_dr=0;    //让LED灭
  59.                          ucLedStep=0; //返回到上一个步骤
  60.                   }
  61.               break;
  62.   
  63.   }

  64. }


  65. /* 注释三:
  66. * C51的中断函数格式如下:
  67. * void 函数名() interrupt 中断号
  68. * {
  69. *    中断程序内容
  70. * }
  71. * 函数名可以随便取,只要不是编译器已经征用的关键字。
  72. * 这里最关键的是中断号,不同的中断号代表不同类型的中断。
  73. * 定时中断的中断号是 1.至于其它中断的中断号,大家可以查找
  74. * 相关书籍和资料。大家进入中断时,必须先清除中断标志,并且
  75. * 关闭中断,然后再写代码,最后出来时,记得重装初始值,并且
  76. * 打开中断。
  77. */
  78. void T0_time() interrupt 1
  79. {
  80.   TF0=0;  //清除中断标志
  81.   TR0=0; //关中断

  82.   if(uiTimeCnt<0xffff)  //设定这个条件,防止uiTimeCnt超范围。
  83.   {
  84.       uiTimeCnt++;  //累加定时中断的次数,
  85.   }

  86. TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  87. TL0=0x2f;
  88. TR0=1;  //开中断
  89. }


  90. void delay_long(unsigned int uiDelayLong)
  91. {
  92.    unsigned int i;
  93.    unsigned int j;
  94.    for(i=0;i<uiDelayLong;i++)
  95.    {
  96.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  97.           {
  98.              ; //一个分号相当于执行一条空语句
  99.           }
  100.    }
  101. }


  102. void initial_myself()  //第一区 初始化单片机
  103. {

  104. /* 注释四:
  105. * 单片机有几个定时器,每个定时器又有几种工作方式,
  106. * 那么多种变化,我们记不了那么多,怎么办?
  107. * 大家记住鸿哥的话,无论一个单片机有多少内置资源,
  108. * 我们做系统框架的,只需要一个定时器,一种工作方式。
  109. * 开定时器越多这个系统越不好。需要哪种定时工作方式呢?
  110. * 就需要响应定时中断后重装一下初始值继续跑那种。
  111. * 在51单片机中就是工作方式1。其它的工作方式很少项目能用到。
  112. */
  113.   TMOD=0x01;  //设置定时器0为工作方式1


  114.   /* 注释五:
  115. * 装定时器的初始值,就像一个水桶里装的水。如果这个桶是空桶,那么想
  116. * 把这个桶灌满水的时间就很长,如果是里面已经装了大半的水,那么想
  117. * 把这个桶灌满水的时间就相对比较短。也就是定时器初始值越小,产生一次
  118. * 定时中断的时间就越长。如果初始值太小了,每次产生定时中断
  119. * 的时间分辨率太粗,如果初始值太大了,虽然每次产生定时中断的时间分辨率很细,
  120. * 但是太频繁的产生中断,不但会影响主函数main()的执行效率,而且累记中断次数
  121. * 的时间误差也会很大。凭鸿哥多年的江湖经验,
  122. * 我觉得最大初始值减去2000是比较好的经验值。当然,大一点小一点没关系。不要走
  123. * 两个极端就行。
  124. */
  125. TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  126. TL0=0x2f;

  127.   led_dr=0;  //LED灭
  128. }
  129. void initial_peripheral() //第二区 初始化外围
  130. {
  131.   EA=1;     //开总中断
  132.   ET0=1;    //允许定时中断
  133.   TR0=1;    //启动定时中断

  134. }
复制代码

总结陈词:
本节程序麻雀虽小五脏俱全。在本节中已经展示了我最完整的实战程序框架。
本节程序只有一个LED灯闪烁的单任务,如果要多增加一个任务来并行处理,该怎么办?
欲知详情,请听下回分解-----蜂鸣器的驱动程序。

(未完待续,下节更精彩,不要走开哦)
此帖出自51单片机论坛

回复

98

帖子

0

TA的资源

一粒金砂(高级)

第五节:蜂鸣器的驱动程序。

开场白:
上一节讲了利用累计定时中断次数实现LED灯闪烁,这个例子同时也第一次展示了我最完整的实战程序框架:用switch语句实现状态机,外加定时中断。这个框架看似简单,实际上就是那么简单。我做的所有开发项目都是基于这个简单框架,但是非常好用。上一节只有一个单任务的LED灯在闪烁,这节开始,我们多增加一个蜂鸣器报警的任务,要教会大家四个知识点:
第一点:蜂鸣器的驱动程序框架编写。
第二点:多任务处理的程序框架。
第三点:如何控制蜂鸣器声音的长叫和短叫。
第四点:如何知道1秒钟需要多少个定时中断,也就是如何按比例修正时间精度。

具体内容,请看源代码讲解。

(1)硬件平台:基于朱兆祺51单片机学习板。

(2)实现功能:同时跑两个任务,第一个任务让一个LED灯1秒钟闪烁一次。第二个任务让蜂鸣器在前面3秒发生一次短叫报警,在后面6秒发生一次长叫报警,反复循环。

(3)源代码讲解如下:
  1. #include "REG52.H"

  2. /* 注释一:
  3. * 如何知道1秒钟需要多少个定时中断?
  4. * 这个需要编写一段小程序测试,得到测试的结果后再按比例修正。
  5. * 步骤:
  6. * 第一步:在程序代码上先写入1秒钟大概需要200个定时中断。
  7. * 第二步:基于以上1秒钟的基准,编写一个60秒的简单测试程序(如果编写超过
  8. * 60秒的时间,这个精度还会更高)。比如,编写一个用蜂鸣器的声音来识别计时的
  9. * 起始和终止的测试程序。
  10. * 第三步:把程序烧录进单片机后,上电开始测试,手上同步打开手机里的秒表。
  11. *         如果单片机仅仅跑了27秒。
  12. * 第四步:那么最终得出1秒钟需要的定时中断次数是:const_time_1s=(200*60)/27=444
  13. */
  14. #define const_time_05s 222   //0.5秒钟的时间需要的定时中断次数
  15. #define const_time_1s 444   //1秒钟的时间需要的定时中断次数
  16. #define const_time_3s 1332   //3秒钟的时间需要的定时中断次数
  17. #define const_time_6s 2664   //6秒钟的时间需要的定时中断次数

  18. #define const_voice_short  40   //蜂鸣器短叫的持续时间
  19. #define const_voice_long   200  //蜂鸣器长叫的持续时间

  20. void initial_myself();   
  21. void initial_peripheral();
  22. void delay_long(unsigned int uiDelaylong);
  23. void led_flicker();
  24. void alarm_run();   
  25. void T0_time();  //定时中断函数

  26. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
  27. sbit led_dr=P3^5;  //LED灯的驱动IO口

  28. unsigned char ucLedStep=0; //LED灯的步骤变量
  29. unsigned int  uiTimeLedCnt=0; //LED灯统计定时中断次数的延时计数器

  30. unsigned char ucAlarmStep=0; //报警的步骤变量
  31. unsigned int  uiTimeAlarmCnt=0; //报警统计定时中断次数的延时计数器

  32. unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器

  33. void main()
  34.   {
  35.    initial_myself();  
  36.    delay_long(100);   
  37.    initial_peripheral();
  38.    while(1)  
  39.    {
  40.       led_flicker();  //第一个任务LED灯闪烁
  41.           alarm_run();    //第二个任务报警器定时报警
  42.    }

  43. }

  44. void led_flicker() //第三区 LED闪烁应用程序
  45. {
  46.   
  47.   switch(ucLedStep)
  48.   {
  49.      case 0:

  50.            if(uiTimeLedCnt>=const_time_05s) //时间到
  51.            {
  52.              uiTimeLedCnt=0; //时间计数器清零
  53.              led_dr=1;    //让LED亮
  54.              ucLedStep=1; //切换到下一个步骤
  55.            }
  56.            break;
  57.      case 1:
  58.            if(uiTimeLedCnt>=const_time_05s) //时间到
  59.            {
  60.               uiTimeLedCnt=0; //时间计数器清零
  61.               led_dr=0;    //让LED灭
  62.               ucLedStep=0; //返回到上一个步骤
  63.            }
  64.            break;
  65.   }

  66. }

  67. void alarm_run() //第三区 报警器的应用程序
  68. {
  69.   
  70.   switch(ucAlarmStep)
  71.   {
  72.      case 0:

  73.            if(uiTimeAlarmCnt>=const_time_3s) //时间到
  74.            {
  75.              uiTimeAlarmCnt=0; //时间计数器清零
  76. /* 注释二:
  77. * 只要变量uiVoiceCnt不为0,蜂鸣器就会在定时中断函数里启动鸣叫,并且自减uiVoiceCnt
  78. * 直到uiVoiceCnt为0时才停止鸣叫。因此控制uiVoiceCnt变量的大小就是控制声音的长短。
  79. */
  80.              uiVoiceCnt=const_voice_short;  //蜂鸣器短叫
  81.              ucAlarmStep=1; //切换到下一个步骤
  82.            }
  83.            break;
  84.      case 1:
  85.            if(uiTimeAlarmCnt>=const_time_6s) //时间到
  86.            {
  87.               uiTimeAlarmCnt=0; //时间计数器清零
  88.               uiVoiceCnt=const_voice_long;  //蜂鸣器长叫
  89.               ucAlarmStep=0; //返回到上一个步骤
  90.            }
  91.            break;
  92.   }

  93. }

  94. void T0_time() interrupt 1
  95. {
  96.   TF0=0;  //清除中断标志
  97.   TR0=0; //关中断

  98.   if(uiTimeLedCnt<0xffff)  //设定这个条件,防止uiTimeLedCnt超范围。
  99.   {
  100.       uiTimeLedCnt++;  //LED灯的时间计数器,累加定时中断的次数,
  101.   }

  102.   if(uiTimeAlarmCnt<0xffff)  //设定这个条件,防止uiTimeAlarmCnt超范围。
  103.   {
  104.       uiTimeAlarmCnt++;  //报警的时间计数器,累加定时中断的次数,
  105.   }


  106. /* 注释三:
  107. * 为什么不把驱动蜂鸣器这段代码放到main函数的循环里去?
  108. * 因为放在定时中断里,能保证蜂鸣器的声音长度是一致的,
  109. * 如果放在main循环里,声音的长度就有可能受到某些必须
  110. * 一气呵成的任务干扰,得不到及时响应,影响声音长度的一致性。
  111. */


  112.   if(uiVoiceCnt!=0)
  113.   {
  114.      uiVoiceCnt--; //每次进入定时中断都自减1,直到等于零为止。才停止鸣叫
  115.          beep_dr=0;  //蜂鸣器是PNP三极管控制,低电平就开始鸣叫。
  116.   }
  117.   else
  118.   {
  119.      ; //此处多加一个空指令,想维持跟if括号语句的数量对称,都是两条指令。不加也可以。
  120.            beep_dr=1;  //蜂鸣器是PNP三极管控制,高电平就停止鸣叫。
  121.   }


  122.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  123.   TL0=0x2f;
  124.   TR0=1;  //开中断
  125. }


  126. void delay_long(unsigned int uiDelayLong)
  127. {
  128.    unsigned int i;
  129.    unsigned int j;
  130.    for(i=0;i<uiDelayLong;i++)
  131.    {
  132.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  133.           {
  134.              ; //一个分号相当于执行一条空语句
  135.           }
  136.    }
  137. }


  138. void initial_myself()  //第一区 初始化单片机
  139. {
  140.   beep_dr=1; //用PNP三极管控制蜂鸣器,输出高电平时不叫。
  141.   led_dr=0;  //LED灭

  142.   TMOD=0x01;  //设置定时器0为工作方式1


  143.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  144.   TL0=0x2f;

  145. }
  146. void initial_peripheral() //第二区 初始化外围
  147. {
  148.   EA=1;     //开总中断
  149.   ET0=1;    //允许定时中断
  150.   TR0=1;    //启动定时中断

  151. }
复制代码


总结陈词:
本节程序已经展示了一个多任务处理的基本思路,假如要实现一个独立按键检测,能不能也按照这种思路来处理呢?欲知详情,请听下回分解-----在主函数中利用累计主循环次数来实现独立按键的检测。

(未完待续,下节更精彩,不要走开哦)
此帖出自51单片机论坛

回复

98

帖子

0

TA的资源

一粒金砂(高级)

第七节:在主函数中利用累计定时中断的次数来实现独立按键的检测。

开场白:
上一节讲了在主函数中利用累计主循环次数来实现独立按键的检测,但是它也有一个小小的不足,随着在主函数中任务量的增加,为了保证去抖动延时的时间一致性,要适当调整一下去抖动的时间阀值const_key_time1。如何解决这个问题呢?这一节教大家在主函数中利用累计定时中断的次数来实现独立按键的检测,可以有效地避免这个问题。要教会大家一个知识点:如何在上一节的基础上,略作修改,就可以在主函数中,利用累计定时中断的次数来实现去抖动的延时。

具体内容,请看源代码讲解。

(1)硬件平台:基于朱兆祺51单片机学习板。用矩阵键盘中的S1和S5号键作为独立按键,记得把输出线P0.4一直输出低电平,模拟独立按键的触发地GND。

(2)实现功能:有两个独立按键,每按一个独立按键,蜂鸣器发出“滴”的一声后就停。

(3)源代码讲解如下:
  1. #include "REG52.H"

  2. #define const_voice_short  40   //蜂鸣器短叫的持续时间


  3. /* 注释一:
  4. * 调整抖动时间阀值的大小,可以更改按键的触发灵敏度。
  5. * 去抖动的时间本质上等于累计定时中断次数的时间。
  6. */
  7. #define const_key_time1  30    //按键去抖动延时的时间
  8. #define const_key_time2  30    //按键去抖动延时的时间

  9. void initial_myself();   
  10. void initial_peripheral();
  11. void delay_long(unsigned int uiDelaylong);
  12. void T0_time();  //定时中断函数
  13. void key_service(); //按键服务的应用程序
  14. void key_scan(); //按键扫描函数

  15. sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
  16. sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键
  17. sbit key_gnd_dr=P0^4; //模拟独立按键的地GND,因此必须一直输出低电平

  18. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口

  19. unsigned char ucKeySec=0;   //被触发的按键编号

  20. unsigned char ucKeyStartFlag1=0; //启动定时中断计数的开关
  21. unsigned int  uiKeyTimeCnt1=0; //按键去抖动延时计数器
  22. unsigned char ucKeyLock1=0; //按键触发后自锁的变量标志

  23. unsigned char ucKeyStartFlag2=0; //启动定时中断计数的开关
  24. unsigned int  uiKeyTimeCnt2=0; //按键去抖动延时计数器
  25. unsigned char ucKeyLock2=0; //按键触发后自锁的变量标志

  26. unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器

  27. void main()
  28.   {
  29.    initial_myself();  
  30.    delay_long(100);   
  31.    initial_peripheral();
  32.    while(1)  
  33.    {
  34.        key_scan(); //按键扫描函数
  35.        key_service(); //按键服务的应用程序
  36.    }

  37. }

  38. void key_scan()//按键扫描函数
  39. {  
  40. /* 注释二:
  41. * 独立按键扫描的详细过程:
  42. * 第一步:平时没有按键被触发时,按键的自锁标志,计时器开关和去抖动延时计数器一直被清零。
  43. * 第二步:一旦有按键被按下,启动计时器,去抖动延时计数器开始在定时中断函数里累加,在还没累加到
  44. *         阀值const_key_time1时,如果在这期间由于受外界干扰或者按键抖动,而使
  45. *         IO口突然瞬间触发成高电平,这个时候马上停止计时,并且把延时计数器uiKeyTimeCnt1
  46. *         清零了,这个过程非常巧妙,非常有效地去除瞬间的杂波干扰。这是我实战中摸索出来的。
  47. *         以后凡是用到开关感应器的时候,都可以用类似这样的方法去干扰。
  48. * 第三步:如果按键按下的时间超过了阀值const_key_time1,则触发按键,把编号ucKeySec赋值。
  49. *         同时,马上把自锁标志ucKeyLock1置位,防止按住按键不松手后一直触发。
  50. * 第四步:等按键松开后,自锁标志ucKeyLock1及时清零,为下一次自锁做准备。
  51. * 第五步:以上整个过程,就是识别按键IO口下降沿触发的过程。
  52. */
  53.   if(key_sr1==1)//IO是高电平,说明按键没有被按下,这时要及时清零一些标志位
  54.   {
  55.      ucKeyLock1=0; //按键自锁标志清零
  56.          ucKeyStartFlag1=0; //停止计数器
  57.          uiKeyTimeCnt1=0;//按键去抖动延时计数器清零,此行非常巧妙,是我实战中摸索出来的。      
  58.   }
  59.   else if(ucKeyLock1==0)//有按键按下,且是第一次被按下
  60.   {
  61.          ucKeyStartFlag1=1; //启动计数器
  62.      if(uiKeyTimeCnt1>const_key_time1)
  63.      {
  64.                  ucKeyStartFlag1=0; //停止计数器
  65.         uiKeyTimeCnt1=0;
  66.         ucKeyLock1=1;  //自锁按键置位,避免一直触发
  67.         ucKeySec=1;    //触发1号键
  68.      }
  69.   }

  70.   if(key_sr2==1)
  71.   {
  72.      ucKeyLock2=0;
  73.          ucKeyStartFlag2=0; //停止计数器
  74.          uiKeyTimeCnt2=0;
  75.   }
  76.   else if(ucKeyLock2==0)
  77.   {
  78.          ucKeyStartFlag2=1; //启动计数器
  79.      if(uiKeyTimeCnt2>const_key_time2)
  80.      {
  81.             ucKeyStartFlag2=0; //停止计数器
  82.         uiKeyTimeCnt2=0;
  83.         ucKeyLock2=1;
  84.         ucKeySec=2;     //触发2号键
  85.      }
  86.   }

  87. }


  88. void key_service() //第三区 按键服务的应用程序
  89. {
  90.   switch(ucKeySec) //按键服务状态切换
  91.   {
  92.     case 1:// 1号键 对应朱兆祺学习板的S1键

  93.               uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  94.               ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  95.           break;        
  96.     case 2:// 2号键 对应朱兆祺学习板的S5键

  97.               uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  98.               ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  99.           break;                    
  100.   }               
  101. }



  102. void T0_time() interrupt 1
  103. {
  104.   TF0=0;  //清除中断标志
  105.   TR0=0; //关中断


  106.   if(ucKeyStartFlag1==1)//启动计数器
  107.   {
  108.      if(uiKeyTimeCnt1<0xffff)  //防止计数器超范围
  109.          {
  110.             uiKeyTimeCnt1++;
  111.          }
  112.   }

  113.    if(ucKeyStartFlag2==1)//启动计数器
  114.   {
  115.      if(uiKeyTimeCnt2<0xffff) //防止计数器超范围
  116.          {
  117.             uiKeyTimeCnt2++;
  118.          }
  119.   }

  120.   if(uiVoiceCnt!=0)
  121.   {
  122.      uiVoiceCnt--; //每次进入定时中断都自减1,直到等于零为止。才停止鸣叫
  123.          beep_dr=0;  //蜂鸣器是PNP三极管控制,低电平就开始鸣叫。
  124.   }
  125.   else
  126.   {
  127.      ; //此处多加一个空指令,想维持跟if括号语句的数量对称,都是两条指令。不加也可以。
  128.            beep_dr=1;  //蜂鸣器是PNP三极管控制,高电平就停止鸣叫。
  129.   }


  130.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  131.   TL0=0x2f;
  132.   TR0=1;  //开中断
  133. }


  134. void delay_long(unsigned int uiDelayLong)
  135. {
  136.    unsigned int i;
  137.    unsigned int j;
  138.    for(i=0;i<uiDelayLong;i++)
  139.    {
  140.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  141.           {
  142.              ; //一个分号相当于执行一条空语句
  143.           }
  144.    }
  145. }


  146. void initial_myself()  //第一区 初始化单片机
  147. {
  148. /* 注释三:
  149. * 矩阵键盘也可以做独立按键,前提是把某一根公共输出线输出低电平,
  150. * 模拟独立按键的触发地,本程序中,把key_gnd_dr输出低电平。
  151. * 朱兆祺51学习板的S1和S5两个按键就是本程序中用到的两个独立按键。
  152. */
  153.   key_gnd_dr=0; //模拟独立按键的地GND,因此必须一直输出低电平


  154.   beep_dr=1; //用PNP三极管控制蜂鸣器,输出高电平时不叫。


  155.   TMOD=0x01;  //设置定时器0为工作方式1


  156.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  157.   TL0=0x2f;

  158. }
  159. void initial_peripheral() //第二区 初始化外围
  160. {
  161.   EA=1;     //开总中断
  162.   ET0=1;    //允许定时中断
  163.   TR0=1;    //启动定时中断

  164. }
复制代码

总结陈词:
本节程序已经展示了在主函数中,利用累计定时中断次数来实现独立按键的检测。这种方法我也经常在实战用应用,但是如果在某些项目中,需要在主函数里间歇性地执行一些一气呵成的耗时任务,这种方法就不是很实用,因为当主函数正在处理一气呵成的耗时任务时,这个时候如果有按键按下来,就有可能没有及时被响应到而遗漏了。那有什么方法可以解决这类项目中遇到的问题?欲知详情,请听下回分解-----在定时中断函数里执行独立按键的扫描程序。

(未完待续,下节更精彩,不要走开哦)
此帖出自51单片机论坛

回复

98

帖子

0

TA的资源

一粒金砂(高级)

第九节:独立按键的双击按键触发。

开场白:
上一节讲了在定时中断函数里处理独立按键的扫描程序,这种结构的程序我用在了很多项目上。这一节教大家如何实现按键双击触发的功能,这种功能类似鼠标的双击。要教会大家一个知识点:如何在上一节的基础上,略作修改,就可以实现按键的双击功能。

具体内容,请看源代码讲解。

(1)硬件平台:基于朱兆祺51单片机学习板。用矩阵键盘中的S1和S5号键作为独立按键,记得把输出线P0.4一直输出低电平,模拟独立按键的触发地GND。

(2)实现功能:有两个独立按键,每双击一个独立按键,蜂鸣器发出“滴”的一声后就停。

(3)源代码讲解如下:
  1. #include "REG52.H"

  2. #define const_voice_short  40   //蜂鸣器短叫的持续时间


  3. /* 注释一:
  4. * 调整抖动时间阀值的大小,可以更改按键的触发灵敏度。
  5. * 去抖动的时间本质上等于累计定时中断次数的时间。
  6. */
  7. #define const_key_time1  20    //按键去抖动延时的时间
  8. #define const_key_time2  20    //按键去抖动延时的时间

  9. /* 注释二:
  10. * 有效时间差,是指连续两次按键触发的最大有效间隔时间。
  11. * 如果双击的两个按键按下的时间间隔太长,则视为无效双击。
  12. */
  13. #define const_interval_time1  200     //连续两次按键之间的有效时间差
  14. #define const_interval_time2  200     //连续两次按键之间的有效时间差

  15. void initial_myself();   
  16. void initial_peripheral();
  17. void delay_long(unsigned int uiDelaylong);
  18. void T0_time();  //定时中断函数
  19. void key_service(); //按键服务的应用程序
  20. void key_scan(); //按键扫描函数 放在定时中断里

  21. sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
  22. sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键
  23. sbit key_gnd_dr=P0^4; //模拟独立按键的地GND,因此必须一直输出低电平

  24. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口

  25. unsigned char ucKeySec=0;   //被触发的按键编号

  26. unsigned int  uiKeyTimeCnt1=0; //按键去抖动延时计数器
  27. unsigned char ucKeyLock1=0; //按键触发后自锁的变量标志
  28. unsigned char ucKeyTouchCnt1=0; //按键按下的次数记录
  29. unsigned int  uiKeyIntervalCnt1=0; //按键间隔的时间计数器

  30. unsigned int  uiKeyTimeCnt2=0; //按键去抖动延时计数器
  31. unsigned char ucKeyLock2=0; //按键触发后自锁的变量标志
  32. unsigned char ucKeyTouchCnt2=0; //按键按下的次数记录
  33. unsigned int  uiKeyIntervalCnt2=0; //按键间隔的时间计数器

  34. unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器

  35. void main()
  36.   {
  37.    initial_myself();  
  38.    delay_long(100);   
  39.    initial_peripheral();
  40.    while(1)  
  41.    {
  42.        key_service(); //按键服务的应用程序
  43.    }

  44. }

  45. void key_scan()//按键扫描函数 放在定时中断里
  46. {  
  47. /* 注释三:
  48. * 独立双击按键扫描的详细过程:
  49. * 第一步:平时没有按键被触发时,按键的自锁标志,去抖动延时计数器一直被清零。
  50. *         如果之前已经有按键触发过一次,那么启动时间间隔计数器uiKeyIntervalCnt1,
  51. *         在这个允许的时间差范围内,如果一直没有第二次按键触发,则把累加按键触发的
  52. *         次数ucKeyTouchCnt1也清零。
  53. * 第二步:一旦有按键被按下,去抖动延时计数器开始在定时中断函数里累加,在还没累加到
  54. *         阀值const_key_time1时,如果在这期间由于受外界干扰或者按键抖动,而使
  55. *         IO口突然瞬间触发成高电平,这个时候马上把延时计数器uiKeyTimeCnt1
  56. *         清零了,这个过程非常巧妙,非常有效地去除瞬间的杂波干扰。这是我实战中摸索出来的。
  57. *         以后凡是用到开关感应器的时候,都可以用类似这样的方法去干扰。
  58. * 第三步:如果按键按下的时间超过了阀值const_key_time1,马上把自锁标志ucKeyLock1置位,
  59. *         防止按住按键不松手后一直触发。与此同时,累加一次按键次数,如果按键次数累加有两次以上,
  60. *         则认为触发双击按键,并把编号ucKeySec赋值。
  61. * 第四步:等按键松开后,自锁标志ucKeyLock1及时清零,为下一次自锁做准备。并且累加间隔时间,
  62. *         防止两次按键的间隔时间太长。
  63. * 第五步:以上整个过程,就是识别按键IO口下降沿触发的过程。
  64. */
  65.   if(key_sr1==1)//IO是高电平,说明按键没有被按下,这时要及时清零一些标志位
  66.   {
  67.          ucKeyLock1=0; //按键自锁标志清零
  68.          uiKeyTimeCnt1=0;//按键去抖动延时计数器清零,此行非常巧妙,是我实战中摸索出来的。      
  69.                  if(ucKeyTouchCnt1>0) //之前已经有按键触发过一次,再来一次就构成双击
  70.                  {
  71.                      uiKeyIntervalCnt1++; //按键间隔的时间计数器累加
  72.                          if(uiKeyIntervalCnt1>const_interval_time1) //超过最大允许的间隔时间
  73.                          {
  74.                             uiKeyIntervalCnt1=0; //时间计数器清零
  75.                             ucKeyTouchCnt1=0; //清零按键的按下的次数
  76.                          }
  77.                  }
  78.   }
  79.   else if(ucKeyLock1==0)//有按键按下,且是第一次被按下
  80.   {
  81.      uiKeyTimeCnt1++; //累加定时中断次数
  82.      if(uiKeyTimeCnt1>const_key_time1)
  83.      {
  84.         uiKeyTimeCnt1=0;
  85.         ucKeyLock1=1;  //自锁按键置位,避免一直触发
  86.                 uiKeyIntervalCnt1=0; //按键有效间隔的时间计数器清零

  87.                 ucKeyTouchCnt1++;
  88.                 if(ucKeyTouchCnt1>1)  //连续被按了两次以上
  89.                 {
  90.                     ucKeyTouchCnt1=0;  //统计按键次数清零
  91.                     ucKeySec=1;    //触发1号键
  92.                 }

  93.      }
  94.   }




  95.   if(key_sr2==1)
  96.   {
  97.          ucKeyLock2=0;
  98.          uiKeyTimeCnt2=0;
  99.                   if(ucKeyTouchCnt2>0)
  100.                  {
  101.                      uiKeyIntervalCnt2++; //按键间隔的时间计数器累加
  102.                          if(uiKeyIntervalCnt2>const_interval_time2) //超过最大允许的间隔时间
  103.                          {
  104.                             uiKeyIntervalCnt2=0; //时间计数器清零
  105.                             ucKeyTouchCnt2=0; //清零按键的按下的次数
  106.                          }
  107.                  }
  108.   }
  109.   else if(ucKeyLock2==0)
  110.   {
  111.      uiKeyTimeCnt2++; //累加定时中断次数
  112.      if(uiKeyTimeCnt2>const_key_time2)
  113.      {
  114.         uiKeyTimeCnt2=0;
  115.         ucKeyLock2=1;
  116.                 uiKeyIntervalCnt2=0; //按键有效间隔的时间计数器清零

  117.                 ucKeyTouchCnt2++;
  118.                 if(ucKeyTouchCnt2>1)  //连续被按了两次以上
  119.                 {
  120.                     ucKeyTouchCnt2=0;  //统计按键次数清零
  121.                     ucKeySec=2;    //触发2号键
  122.                 }
  123.      }
  124.   }

  125. }


  126. void key_service() //第三区 按键服务的应用程序
  127. {
  128.   switch(ucKeySec) //按键服务状态切换
  129.   {
  130.     case 1:// 1号键 双击  对应朱兆祺学习板的S1键

  131.               uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  132.               ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  133.           break;        
  134.     case 2:// 2号键 双击  对应朱兆祺学习板的S5键

  135.               uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  136.               ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  137.           break;                    
  138.   }               
  139. }



  140. void T0_time() interrupt 1
  141. {
  142.   TF0=0;  //清除中断标志
  143.   TR0=0; //关中断

  144.   key_scan(); //按键扫描函数

  145.   if(uiVoiceCnt!=0)
  146.   {
  147.      uiVoiceCnt--; //每次进入定时中断都自减1,直到等于零为止。才停止鸣叫
  148.          beep_dr=0;  //蜂鸣器是PNP三极管控制,低电平就开始鸣叫。
  149.   }
  150.   else
  151.   {
  152.      ; //此处多加一个空指令,想维持跟if括号语句的数量对称,都是两条指令。不加也可以。
  153.            beep_dr=1;  //蜂鸣器是PNP三极管控制,高电平就停止鸣叫。
  154.   }


  155.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  156.   TL0=0x2f;
  157.   TR0=1;  //开中断
  158. }


  159. void delay_long(unsigned int uiDelayLong)
  160. {
  161.    unsigned int i;
  162.    unsigned int j;
  163.    for(i=0;i<uiDelayLong;i++)
  164.    {
  165.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  166.           {
  167.              ; //一个分号相当于执行一条空语句
  168.           }
  169.    }
  170. }


  171. void initial_myself()  //第一区 初始化单片机
  172. {
  173. /* 注释四:
  174. * 矩阵键盘也可以做独立按键,前提是把某一根公共输出线输出低电平,
  175. * 模拟独立按键的触发地,本程序中,把key_gnd_dr输出低电平。
  176. * 朱兆祺51学习板的S1和S5两个按键就是本程序中用到的两个独立按键。
  177. */
  178.   key_gnd_dr=0; //模拟独立按键的地GND,因此必须一直输出低电平


  179.   beep_dr=1; //用PNP三极管控制蜂鸣器,输出高电平时不叫。


  180.   TMOD=0x01;  //设置定时器0为工作方式1


  181.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  182.   TL0=0x2f;

  183. }
  184. void initial_peripheral() //第二区 初始化外围
  185. {
  186.   EA=1;     //开总中断
  187.   ET0=1;    //允许定时中断
  188.   TR0=1;    //启动定时中断

  189. }
复制代码

总结陈词:
假如要两个独立按键实现组合按键的功能,我们该怎么写程序?欲知详情,请听下回分解-----独立按键的组合按键触发。

(未完待续,下节更精彩,不要走开哦)
此帖出自51单片机论坛

回复

98

帖子

0

TA的资源

一粒金砂(高级)

第十节:两个独立按键的组合按键触发。

开场白:
上一节讲了按键双击触发功能的程序,这一节讲类似电脑键盘组合按键触发的功能,要教会大家一个知识点:如何在上一节的基础上,略作修改,就可以实现两个独立按键的组合按键触发功能。

具体内容,请看源代码讲解。

(1)硬件平台:基于朱兆祺51单片机学习板。用矩阵键盘中的S1和S5号键作为独立按键,记得把输出线P0.4一直输出低电平,模拟独立按键的触发地GND。

(2)实现功能:有两个独立按键,当把两个独立按键都按下后,蜂鸣器发出“滴”的一声后就停。直到松开任一个按键后,才能重新进行下一次的组合按键触发。

(3)源代码讲解如下:
  1. #include "REG52.H"

  2. #define const_voice_short  40   //蜂鸣器短叫的持续时间


  3. /* 注释一:
  4. * 调整抖动时间阀值的大小,可以更改按键的触发灵敏度。
  5. * 去抖动的时间本质上等于累计定时中断次数的时间。
  6. */
  7. #define const_key_time12  20    //按键去抖动延时的时间


  8. void initial_myself();   
  9. void initial_peripheral();
  10. void delay_long(unsigned int uiDelaylong);
  11. void T0_time();  //定时中断函数
  12. void key_service(); //按键服务的应用程序
  13. void key_scan(); //按键扫描函数 放在定时中断里

  14. sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
  15. sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键
  16. sbit key_gnd_dr=P0^4; //模拟独立按键的地GND,因此必须一直输出低电平

  17. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口

  18. unsigned char ucKeySec=0;   //被触发的按键编号

  19. unsigned int  uiKeyTimeCnt12=0; //按键去抖动延时计数器
  20. unsigned char ucKeyLock12=0; //按键触发后自锁的变量标志


  21. unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器

  22. void main()
  23.   {
  24.    initial_myself();  
  25.    delay_long(100);   
  26.    initial_peripheral();
  27.    while(1)  
  28.    {
  29.        key_service(); //按键服务的应用程序
  30.    }

  31. }

  32. void key_scan()//按键扫描函数 放在定时中断里
  33. {  
  34. /* 注释二:
  35. * 独立组合按键扫描的详细过程:
  36. * 第一步:平时只要两个按键中有一个没有被按下时,按键的自锁标志,去抖动延时计数器一直被清零。
  37. * 第二步:一旦两个按键都被按下,去抖动延时计数器开始在定时中断函数里累加,在还没累加到
  38. *         阀值const_key_time12时,如果在这期间由于受外界干扰或者按键抖动,而使
  39. *         IO口突然瞬间触发成高电平,这个时候马上把延时计数器uiKeyTimeCnt12
  40. *         清零了,这个过程非常巧妙,非常有效地去除瞬间的杂波干扰。这是我实战中摸索出来的。
  41. *         以后凡是用到开关感应器的时候,都可以用类似这样的方法去干扰。
  42. * 第三步:如果按键按下的时间超过了阀值const_key_time12,马上把自锁标志ucKeyLock12置位,
  43. *         防止按住按键不松手后一直触发。并把编号ucKeySec赋值。 组合按键触发
  44. * 第四步:等按键松开后,自锁标志ucKeyLock12及时清零,为下一次自锁做准备。
  45. * 第五步:以上整个过程,就是识别按键IO口下降沿触发的过程。
  46. */
  47.   if(key_sr1==1||key_sr2==1)//IO是高电平,说明两个按键没有全部被按下,这时要及时清零一些标志位
  48.   {
  49.          ucKeyLock12=0; //按键自锁标志清零
  50.          uiKeyTimeCnt12=0;//按键去抖动延时计数器清零,此行非常巧妙,是我实战中摸索出来的。      
  51.   }
  52.   else if(ucKeyLock12==0)//有按键按下,且是第一次被按下
  53.   {
  54.      uiKeyTimeCnt12++; //累加定时中断次数
  55.      if(uiKeyTimeCnt12>const_key_time12)
  56.      {
  57.         uiKeyTimeCnt12=0;
  58.         ucKeyLock12=1;  //自锁按键置位,避免一直触发
  59.         ucKeySec=1;    //触发1号键
  60.               
  61.      }
  62.   }




  63. }


  64. void key_service() //第三区 按键服务的应用程序
  65. {
  66.   switch(ucKeySec) //按键服务状态切换
  67.   {
  68.     case 1:// 1号键 组合按键  对应朱兆祺学习板的S1键和S5键

  69.               uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  70.               ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  71.           break;        
  72.               
  73.   }               
  74. }



  75. void T0_time() interrupt 1
  76. {
  77.   TF0=0;  //清除中断标志
  78.   TR0=0; //关中断

  79.   key_scan(); //按键扫描函数

  80.   if(uiVoiceCnt!=0)
  81.   {
  82.      uiVoiceCnt--; //每次进入定时中断都自减1,直到等于零为止。才停止鸣叫
  83.          beep_dr=0;  //蜂鸣器是PNP三极管控制,低电平就开始鸣叫。
  84.   }
  85.   else
  86.   {
  87.      ; //此处多加一个空指令,想维持跟if括号语句的数量对称,都是两条指令。不加也可以。
  88.            beep_dr=1;  //蜂鸣器是PNP三极管控制,高电平就停止鸣叫。
  89.   }


  90.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  91.   TL0=0x2f;
  92.   TR0=1;  //开中断
  93. }


  94. void delay_long(unsigned int uiDelayLong)
  95. {
  96.    unsigned int i;
  97.    unsigned int j;
  98.    for(i=0;i<uiDelayLong;i++)
  99.    {
  100.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  101.           {
  102.              ; //一个分号相当于执行一条空语句
  103.           }
  104.    }
  105. }


  106. void initial_myself()  //第一区 初始化单片机
  107. {
  108. /* 注释三:
  109. * 矩阵键盘也可以做独立按键,前提是把某一根公共输出线输出低电平,
  110. * 模拟独立按键的触发地,本程序中,把key_gnd_dr输出低电平。
  111. * 朱兆祺51学习板的S1和S5两个按键就是本程序中用到的两个独立按键。
  112. */
  113.   key_gnd_dr=0; //模拟独立按键的地GND,因此必须一直输出低电平


  114.   beep_dr=1; //用PNP三极管控制蜂鸣器,输出高电平时不叫。


  115.   TMOD=0x01;  //设置定时器0为工作方式1


  116.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  117.   TL0=0x2f;

  118. }
  119. void initial_peripheral() //第二区 初始化外围
  120. {
  121.   EA=1;     //开总中断
  122.   ET0=1;    //允许定时中断
  123.   TR0=1;    //启动定时中断

  124. }
复制代码

总结陈词:
以前寻呼机流行的时候,寻呼机往往只有一个设置按键,它要求用一个按键来设置不同的参数,这个时候就要用到同一个按键来实现短按和长按的区别触发功能。要现实这种功能,我们该怎么写程序?欲知详情,请听下回分解-----同一个按键短按与长按的区别触发。

(未完待续,下节更精彩,不要走开哦)
此帖出自51单片机论坛

回复

98

帖子

0

TA的资源

一粒金砂(高级)

第十一节:同一个按键短按与长按的区别触发。

开场白:
上一节讲了类似电脑键盘组合按键触发的功能,这节要教会大家一个知识点:如何在上一节的基础上,略作修改,就可以实现同一个按键短按与长按的区别触发。

具体内容,请看源代码讲解。

(1)硬件平台:基于朱兆祺51单片机学习板。用矩阵键盘中的S1和S5号键作为独立按键,记得把输出线P0.4一直输出低电平,模拟独立按键的触发地GND。

(2)实现功能:两个独立按键S1和S5,按住其中一个按键,在短时间内松手,则认为是短按,触发蜂鸣器短鸣一声。如果一直按住这个按键不松手,那么超过规定的长时间内,则认为是长按,触发蜂鸣器长鸣一声。

(3)源代码讲解如下:
  1. #include "REG52.H"

  2. #define const_voice_short  20   //蜂鸣器短叫的持续时间
  3. #define const_voice_long   140   //蜂鸣器长叫的持续时间

  4. /* 注释一:
  5. * 调整抖动时间阀值的大小,可以更改按键的触发灵敏度。
  6. * 去抖动的时间本质上等于累计定时中断次数的时间。
  7. */
  8. #define const_key_time_short1  20    //短按的按键去抖动延时的时间
  9. #define const_key_time_long1   400     //长按的按键去抖动延时的时间

  10. #define const_key_time_short2  20    //短按的按键去抖动延时的时间
  11. #define const_key_time_long2   400     //长按的按键去抖动延时的时间

  12. void initial_myself();   
  13. void initial_peripheral();
  14. void delay_long(unsigned int uiDelaylong);
  15. void T0_time();  //定时中断函数
  16. void key_service(); //按键服务的应用程序
  17. void key_scan(); //按键扫描函数 放在定时中断里

  18. sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
  19. sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键
  20. sbit key_gnd_dr=P0^4; //模拟独立按键的地GND,因此必须一直输出低电平

  21. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口

  22. unsigned char ucKeySec=0;   //被触发的按键编号

  23. unsigned int  uiKeyTimeCnt1=0; //按键去抖动延时计数器
  24. unsigned char ucKeyLock1=0; //按键触发后自锁的变量标志
  25. unsigned char ucShortTouchFlag1=0; //短按的触发标志

  26. unsigned int  uiKeyTimeCnt2=0; //按键去抖动延时计数器
  27. unsigned char ucKeyLock2=0; //按键触发后自锁的变量标志
  28. unsigned char ucShortTouchFlag2=0; //短按的触发标志

  29. unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器

  30. void main()
  31.   {
  32.    initial_myself();  
  33.    delay_long(100);   
  34.    initial_peripheral();
  35.    while(1)  
  36.    {
  37.        key_service(); //按键服务的应用程序
  38.    }

  39. }

  40. void key_scan()//按键扫描函数 放在定时中断里
  41. {  
  42. /* 注释二:
  43. * 长按与短按的按键扫描的详细过程:
  44. * 第一步:平时只要按键没有被按下时,按键的自锁标志,去抖动延时计数器一直被清零。
  45. * 第二步:一旦两个按键都被按下,去抖动延时计数器开始在定时中断函数里累加,在还没累加到
  46. *         阀值const_key_time_short1或者const_key_time_long1时,如果在这期间由于受外界干扰或者按键抖动,而使
  47. *         IO口突然瞬间触发成高电平,这个时候马上把延时计数器uiKeyTimeCnt1
  48. *         清零了,这个过程非常巧妙,非常有效地去除瞬间的杂波干扰。这是我实战中摸索出来的。
  49. *         以后凡是用到开关感应器的时候,都可以用类似这样的方法去干扰。
  50. * 第三步:如果按键按下的时间超过了短按阀值const_key_time_short1,则马上把短按标志ucShortTouchFlag1=1;
  51. *         如果还没有松手,一旦发现按下的时间超过长按阀值const_key_time_long1时,
  52. *         先把短按标志ucShortTouchFlag1清零,然后触发长按。在这段程序里,把自锁标志ucKeyLock1置位,
  53. *         是为了防止按住按键不松手后一直触发。
  54. * 第四步:等按键松开后,自锁标志ucKeyLock12及时清零,为下一次自锁做准备。如果发现ucShortTouchFlag1等于1,
  55. *         说明短按有效,这时触发一次短按。
  56. * 第五步:以上整个过程,就是识别按键IO口下降沿触发的过程。
  57. */
  58.   if(key_sr1==1)//IO是高电平,说明两个按键没有全部被按下,这时要及时清零一些标志位
  59.   {
  60.       ucKeyLock1=0; //按键自锁标志清零
  61.       uiKeyTimeCnt1=0;//按键去抖动延时计数器清零,此行非常巧妙,是我实战中摸索出来的。   
  62.             if(ucShortTouchFlag1==1)  //短按触发标志
  63.           {
  64.              ucShortTouchFlag1=0;
  65.                  ucKeySec=1;    //触发一号键的短按
  66.           }
  67.   }
  68.   else if(ucKeyLock1==0)//有按键按下,且是第一次被按下
  69.   {
  70.      uiKeyTimeCnt1++; //累加定时中断次数
  71.      if(uiKeyTimeCnt1>const_key_time_short1)
  72.      {
  73.             ucShortTouchFlag1=1;   //激活按键短按的有效标志  
  74.      }

  75.      if(uiKeyTimeCnt1>const_key_time_long1)
  76.      {
  77.             ucShortTouchFlag1=0;  //清除按键短按的有效标志

  78.         uiKeyTimeCnt1=0;
  79.         ucKeyLock1=1;  //自锁按键置位,避免一直触发

  80.         ucKeySec=2;    //触发1号键的长按
  81.               
  82.      }

  83.   }

  84.   if(key_sr2==1)//IO是高电平,说明两个按键没有全部被按下,这时要及时清零一些标志位
  85.   {
  86.       ucKeyLock2=0; //按键自锁标志清零
  87.       uiKeyTimeCnt2=0;//按键去抖动延时计数器清零,此行非常巧妙,是我实战中摸索出来的。   
  88.             if(ucShortTouchFlag2==1)  //短按触发标志
  89.           {
  90.              ucShortTouchFlag2=0;
  91.                  ucKeySec=3;    //触发2号键的短按
  92.           }
  93.   }
  94.   else if(ucKeyLock2==0)//有按键按下,且是第一次被按下
  95.   {
  96.      uiKeyTimeCnt2++; //累加定时中断次数
  97.      if(uiKeyTimeCnt2>const_key_time_short2)
  98.      {
  99.             ucShortTouchFlag2=1;   //激活按键短按的有效标志  
  100.      }

  101.      if(uiKeyTimeCnt2>const_key_time_long2)
  102.      {
  103.             ucShortTouchFlag2=0;  //清除按键短按的有效标志

  104.         uiKeyTimeCnt2=0;
  105.         ucKeyLock2=1;  //自锁按键置位,避免一直触发

  106.         ucKeySec=4;    //触发2号键的长按
  107.               
  108.      }

  109.   }


  110. }


  111. void key_service() //第三区 按键服务的应用程序
  112. {
  113.   switch(ucKeySec) //按键服务状态切换
  114.   {
  115.     case 1:// 1号键的短按  对应朱兆祺学习板的S1键

  116.           uiVoiceCnt=const_voice_short; //按键声音的短触发,滴一声就停。
  117.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  118.           break;        
  119.     case 2:// 1号键的长按  对应朱兆祺学习板的S1键

  120.           uiVoiceCnt=const_voice_long; //按键声音的长触发,滴一声就停。
  121.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  122.           break;      
  123.     case 3:// 2号键的短按  对应朱兆祺学习板的S5键

  124.           uiVoiceCnt=const_voice_short; //按键声音的短触发,滴一声就停。
  125.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  126.           break;        
  127.     case 4:// 2号键的长按  对应朱兆祺学习板的S5键

  128.           uiVoiceCnt=const_voice_long; //按键声音的长触发,滴一声就停。
  129.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  130.           break;   
  131.   }               
  132. }



  133. void T0_time() interrupt 1
  134. {
  135.   TF0=0;  //清除中断标志
  136.   TR0=0; //关中断

  137.   key_scan(); //按键扫描函数

  138.   if(uiVoiceCnt!=0)
  139.   {
  140.      uiVoiceCnt--; //每次进入定时中断都自减1,直到等于零为止。才停止鸣叫
  141.          beep_dr=0;  //蜂鸣器是PNP三极管控制,低电平就开始鸣叫。
  142.   }
  143.   else
  144.   {
  145.      ; //此处多加一个空指令,想维持跟if括号语句的数量对称,都是两条指令。不加也可以。
  146.            beep_dr=1;  //蜂鸣器是PNP三极管控制,高电平就停止鸣叫。
  147.   }


  148.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  149.   TL0=0x2f;
  150.   TR0=1;  //开中断
  151. }


  152. void delay_long(unsigned int uiDelayLong)
  153. {
  154.    unsigned int i;
  155.    unsigned int j;
  156.    for(i=0;i<uiDelayLong;i++)
  157.    {
  158.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  159.           {
  160.              ; //一个分号相当于执行一条空语句
  161.           }
  162.    }
  163. }


  164. void initial_myself()  //第一区 初始化单片机
  165. {
  166. /* 注释三:
  167. * 矩阵键盘也可以做独立按键,前提是把某一根公共输出线输出低电平,
  168. * 模拟独立按键的触发地,本程序中,把key_gnd_dr输出低电平。
  169. * 朱兆祺51学习板的S1和S5两个按键就是本程序中用到的两个独立按键。
  170. */
  171.   key_gnd_dr=0; //模拟独立按键的地GND,因此必须一直输出低电平


  172.   beep_dr=1; //用PNP三极管控制蜂鸣器,输出高电平时不叫。


  173.   TMOD=0x01;  //设置定时器0为工作方式1


  174.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  175.   TL0=0x2f;

  176. }
  177. void initial_peripheral() //第二区 初始化外围
  178. {
  179.   EA=1;     //开总中断
  180.   ET0=1;    //允许定时中断
  181.   TR0=1;    //启动定时中断

  182. }
复制代码

总结陈词:
    在很多需要人机交互的项目中,需要用按键来快速加减某个数值,这个时候如果按住一个按键不松手,这个数值要有节奏地快速往上加或者快速往下减。要现实这种功能,我们该怎么写程序?欲知详情,请听下回分解-----按住一个独立按键不松手的连续步进触发。

(未完待续,下节更精彩,不要走开哦)
此帖出自51单片机论坛

回复

98

帖子

0

TA的资源

一粒金砂(高级)

第十二节:按住一个独立按键不松手的连续步进触发。

开场白:
上一节讲了同一个按键短按与长按的区别触发功能,这节要教会大家两个知识点:
第一个知识点:如何在上一节的基础上,略作修改,就可以实现按住一个独立按键不松手的连续步进触发。
第二个知识点:在单片机的C语言编译器中,当无符号数据0减去1时,就会溢出,变成这个类型数据的最大值。比如是unsigned int类型的0减去1就等于65535(0xffff),unsigned char类型的0减去1就等于255(0xff)。这个常识经常要用在判断数据临界点的地方。比如一个数最大值是20,最小值是0。这个数据一直往下减,当我们发现它突然大于20的时候,就知道它溢出了,这个时候要及时把它赋值成0就达到我们的目的。

具体内容,请看源代码讲解。

(1)硬件平台:基于朱兆祺51单片机学习板。用矩阵键盘中的S1和S5号键作为独立按键,记得把输出线P0.4一直输出低电平,模拟独立按键的触发地GND。

(2)实现功能:两个独立按键S1和S5,S1键作为加键。S5键做为减键。每按一次S1键则被设置参数uiSetNumber自加1。如果按住S1键不松手超过1秒钟,被设置参数uiSetNumber以每0.25秒的时间间隔往上自加1,一直加到20为止。每按一次S5键则被设置参数uiSetNumber自减1。如果按住S5键不松手超过1秒钟,被设置参数uiSetNumber以每0.25秒的时间间隔往下自减1,一直减到0为止。当被设置参数uiSetNumber小于10的时候,LED灯灭;当大于或者等于10的时候,LED灯亮。


(3)源代码讲解如下:
  1. #include "REG52.H"

  2. #define const_voice_short  40   //蜂鸣器短叫的持续时间

  3. #define const_key_time1  20    //按键去抖动延时的时间
  4. #define const_key_time2  20    //按键去抖动延时的时间

  5. #define const_time_0_25s  111   //0.25秒钟的时间需要的定时中断次数
  6. #define const_time_1s     444   //1秒钟的时间需要的定时中断次数



  7. void initial_myself();   
  8. void initial_peripheral();
  9. void delay_long(unsigned int uiDelaylong);
  10. void T0_time();  //定时中断函数
  11. void key_service(); //按键服务的应用程序
  12. void key_scan(); //按键扫描函数 放在定时中断里
  13. void led_run();  //led灯的应用程序

  14. sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
  15. sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键
  16. sbit key_gnd_dr=P0^4; //模拟独立按键的地GND,因此必须一直输出低电平

  17. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口

  18. sbit led_dr=P3^5;  //LED的驱动IO口


  19. unsigned char ucKeySec=0;   //被触发的按键编号

  20. unsigned int  uiKeyTimeCnt1=0; //按键去抖动延时计数器
  21. unsigned int  uiKeyCtntyCnt1=0;  //按键连续触发的间隔延时计数器
  22. unsigned char ucKeyLock1=0; //按键触发后自锁的变量标志


  23. unsigned int  uiKeyTimeCnt2=0; //按键去抖动延时计数器
  24. unsigned int  uiKeyCtntyCnt2=0;  //按键连续触发的间隔延时计数器
  25. unsigned char ucKeyLock2=0; //按键触发后自锁的变量标志

  26. unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器

  27. unsigned int  uiSetNumber=0; //设置的数据

  28. void main()
  29.   {
  30.    initial_myself();  
  31.    delay_long(100);   
  32.    initial_peripheral();
  33.    while(1)  
  34.    {
  35.        key_service(); //按键服务的应用程序
  36.            led_run();  //led灯的应用程序
  37.    }

  38. }

  39. void led_run()  //led灯的应用程序
  40. {
  41.    if(uiSetNumber<10)  //如果被设置的参数uiSetNumber小于10,LED灯则灭。否则亮。
  42.    {
  43.       led_dr=0;  //灭
  44.    }
  45.    else
  46.    {
  47.       led_dr=1;  //亮
  48.    }
  49. }


  50. void key_scan()//按键扫描函数 放在定时中断里
  51. {  
  52. /* 注释一:
  53. * 独立按键扫描的详细过程:
  54. * 第一步:平时没有按键被触发时,按键的自锁标志,去抖动延时计数器,以及时间间隔延时计数器一直被清零。
  55. * 第二步:一旦有按键被按下,去抖动延时计数器开始在定时中断函数里累加,在还没累加到
  56. *         阀值const_key_time1时,如果在这期间由于受外界干扰或者按键抖动,而使
  57. *         IO口突然瞬间触发成高电平,这个时候马上把延时计数器uiKeyTimeCnt1
  58. *         清零了,这个过程非常巧妙,非常有效地去除瞬间的杂波干扰。这是我实战中摸索出来的。
  59. *         以后凡是用到开关感应器的时候,都可以用类似这样的方法去干扰。
  60. * 第三步:如果按键按下的时间超过了阀值const_key_time1,则触发按键,把编号ucKeySec赋值。
  61. *         同时,马上把自锁标志ucKeyLock1置位,防止按住按键不松手后一直触发。
  62. * 第四步:如果此时触发了一次按键后,一直不松手,去抖动延时计时器继续累加,直到超过了1秒钟。进入连续触发模式的程序
  63. * 第五步:在连续触发模式的程序中,连续累加延时计数器开始累加,每0.25秒就触发一次。
  64. * 第六步:等按键松开后,自锁标志ucKeyLock1和两个延时计时器及时清零,为下一次自锁做准备。
  65. */
  66.   if(key_sr1==1)//IO是高电平,说明按键没有被按下,这时要及时清零一些标志位
  67.   {
  68.      ucKeyLock1=0; //按键自锁标志清零
  69.      uiKeyTimeCnt1=0;//按键去抖动延时计数器清零,此行非常巧妙,是我实战中摸索出来的。   
  70.      uiKeyCtntyCnt1=0; //连续累加的时间间隔延时计数器清零
  71.   }
  72.   else if(ucKeyLock1==0)//有按键按下,且是第一次被按下
  73.   {
  74.      uiKeyTimeCnt1++; //累加定时中断次数
  75.      if(uiKeyTimeCnt1>const_key_time1)
  76.      {
  77.         uiKeyTimeCnt1=0;
  78.         ucKeyLock1=1;  //自锁按键置位,避免一直触发
  79.         ucKeySec=1;    //触发1号键
  80.      }
  81.   }
  82.   else if(uiKeyTimeCnt1<const_time_1s) //按住累加到1秒
  83.   {
  84.      uiKeyTimeCnt1++;
  85.   }
  86.   else  //按住累加到1秒后仍然不放手,这个时候进入有节奏的连续触发
  87.   {
  88.      uiKeyCtntyCnt1++; //连续触发延时计数器累加
  89.          if(uiKeyCtntyCnt1>const_time_0_25s)  //按住没松手,每0.25秒就触发一次
  90.          {
  91.              uiKeyCtntyCnt1=0; //
  92.          ucKeySec=1;    //触发1号键
  93.          }
  94.    
  95.   }



  96.   if(key_sr2==1)
  97.   {
  98.      ucKeyLock2=0;
  99.      uiKeyTimeCnt2=0;
  100.          uiKeyCtntyCnt2=0;
  101.   }
  102.   else if(ucKeyLock2==0)
  103.   {
  104.      uiKeyTimeCnt2++; //累加定时中断次数
  105.      if(uiKeyTimeCnt2>const_key_time2)
  106.      {
  107.         uiKeyTimeCnt2=0;
  108.         ucKeyLock2=1;
  109.         ucKeySec=2;     //触发2号键
  110.      }
  111.   }
  112.   else if(uiKeyTimeCnt2<const_time_1s)
  113.   {
  114.       uiKeyTimeCnt2++;
  115.   }
  116.   else
  117.   {
  118.       uiKeyCtntyCnt2++;
  119.           if(uiKeyCtntyCnt2>const_time_0_25s)
  120.           {
  121.              uiKeyCtntyCnt2=0;
  122.                  ucKeySec=2;     //触发2号键
  123.           }
  124.   }

  125. }


  126. void key_service() //第三区 按键服务的应用程序
  127. {
  128.   switch(ucKeySec) //按键服务状态切换
  129.   {
  130.     case 1:// 1号键 连续加键  对应朱兆祺学习板的S1键  
  131.               uiSetNumber++; //被设置的参数连续往上加
  132.                           if(uiSetNumber>20) //最大是20
  133.                           {
  134.                             uiSetNumber=20;
  135.                           }
  136.               uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  137.               ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  138.           break;        
  139.     case 2:// 2号键 连续减键  对应朱兆祺学习板的S5键
  140. /* 注释二:
  141. * 在单片机的C语言编译器中,当无符号数据0减去1时,就会溢出,变成这个类型数据的最大值。
  142. * 比如是unsigned int的0减去1就等于65535(0xffff),unsigned char的0减去1就等于255(0xff)
  143. */
  144.               uiSetNumber--; //被设置的参数连续往下减
  145.                           if(uiSetNumber>20) //最小是0.为什么这里用20?因为0减去1就是溢出变成了65535(0xffff)
  146.                           {
  147.                             uiSetNumber=0;
  148.                           }
  149.               uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  150.               ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  151.           break;                    
  152.   }               
  153. }



  154. void T0_time() interrupt 1
  155. {
  156.   TF0=0;  //清除中断标志
  157.   TR0=0; //关中断

  158.   key_scan(); //按键扫描函数

  159.   if(uiVoiceCnt!=0)
  160.   {
  161.      uiVoiceCnt--; //每次进入定时中断都自减1,直到等于零为止。才停止鸣叫
  162.          beep_dr=0;  //蜂鸣器是PNP三极管控制,低电平就开始鸣叫。
  163.   }
  164.   else
  165.   {
  166.      ; //此处多加一个空指令,想维持跟if括号语句的数量对称,都是两条指令。不加也可以。
  167.            beep_dr=1;  //蜂鸣器是PNP三极管控制,高电平就停止鸣叫。
  168.   }


  169.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  170.   TL0=0x2f;
  171.   TR0=1;  //开中断
  172. }


  173. void delay_long(unsigned int uiDelayLong)
  174. {
  175.    unsigned int i;
  176.    unsigned int j;
  177.    for(i=0;i<uiDelayLong;i++)
  178.    {
  179.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  180.           {
  181.              ; //一个分号相当于执行一条空语句
  182.           }
  183.    }
  184. }


  185. void initial_myself()  //第一区 初始化单片机
  186. {
  187. /* 注释三:
  188. * 矩阵键盘也可以做独立按键,前提是把某一根公共输出线输出低电平,
  189. * 模拟独立按键的触发地,本程序中,把key_gnd_dr输出低电平。
  190. * 朱兆祺51学习板的S1和S5两个按键就是本程序中用到的两个独立按键。
  191. */
  192.   key_gnd_dr=0; //模拟独立按键的地GND,因此必须一直输出低电平


  193.   beep_dr=1; //用PNP三极管控制蜂鸣器,输出高电平时不叫。
  194.   led_dr=0;  //LED灯灭

  195.   TMOD=0x01;  //设置定时器0为工作方式1


  196.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  197.   TL0=0x2f;

  198. }
  199. void initial_peripheral() //第二区 初始化外围
  200. {
  201.   EA=1;     //开总中断
  202.   ET0=1;    //允许定时中断
  203.   TR0=1;    //启动定时中断

  204. }
复制代码

总结陈词:
本程序可以有节奏地快速往上加或者快速往下减。假如被设置数据的范围不是20,而是1000。如果按0.25秒的节奏往上加,那不是累死人了?如果直接把0.25秒的节奏调快到0.01秒,那么到达999的时候,还来不及松手就很容易超过头,不好微调。有没有完整的方案解决这个问题?当然有。欲知详情,请听下回分解-----按住一个独立按键不松手的加速匀速触发。

(未完待续,下节更精彩,不要走开哦)
此帖出自51单片机论坛

回复

98

帖子

0

TA的资源

一粒金砂(高级)

第十三节:按住一个独立按键不松手的加速匀速触发。

开场白:
上一节讲了按住一个独立按键不松手的连续步进触发功能,这节要教会大家如何在上一节的基础上,略作修改,就可以实现按键的加速匀速触发。

具体内容,请看源代码讲解。

(1)硬件平台:基于朱兆祺51单片机学习板。用矩阵键盘中的S1和S5号键作为独立按键,记得把输出线P0.4一直输出低电平,模拟独立按键的触发地GND。

(2)实现功能:两个独立按键S1和S5,S1键作为加键。S5键做为减键。每按一次S1键则被设置参数uiSetNumber自加1。如果按住S1键不松手超过1秒钟,被设置参数uiSetNumber以不断变快的时间间隔往上自加1,这个称为加速触发的功能,直到到达极限值,则以固定的速度加1,这个过程叫匀速。S5作为减法按键,每触发一次,uiSetNumber就减1,其加速和匀速触发功能跟S1按键一样。当被设置参数uiSetNumber小于500的时候,LED灯灭;当大于或者等于500的时候,LED灯亮。需要注意的是:
第一步:每次按下去触发一次单击按键,如果按下去到松手的时间不超过1秒,则不会进入连续加速触发模式。
第二步:如果按下去不松手的时间超过1秒,则进入连续加速触发模式。按键触发节奏不断加快,蜂鸣器鸣叫的节奏也不断加快。直到它们都到达一个极限值,然后以此极限值间隔匀速触发。在刚开始加速的时候,按键触发与蜂鸣器触发的步骤是一致的,等它们任意一个达到极限值的时候,急促的声音跟按键的触发不一致,并不是蜂鸣器每叫一次,按键就触发一次。实际上加速到最后,按键触发的速度远远比蜂鸣器的触发速度快。

(3)源代码讲解如下:
  1. #include "REG52.H"

  2. #define const_voice_short  40   //蜂鸣器短叫的持续时间

  3. #define const_key_time1  20    //按键去抖动延时的时间
  4. #define const_key_time2  20    //按键去抖动延时的时间

  5. #define const_time_1s     444   //1秒钟的时间需要的定时中断次数

  6. #define const_initial_set 160  //连续触发模式的时候,按键刚开始的间隔触发时间
  7. #define const_min_level  30    //连续触发模式的时候,按键经过加速后,如果一旦发现小于这个值,则直接变到最后的间隔触发时间
  8. #define const_sub_dt  10       //按键的"加速度",相当于按键间隔时间每次的变化量

  9. #define const_last_min_set 5    //连续触发模式的时候,按键经过加速后,最后的间隔触发时间

  10. #define const_syn_min_level  45 //产生同步声音的最小阀值 这个时间必须要比蜂鸣器的时间略长一点。


  11. void initial_myself();   
  12. void initial_peripheral();
  13. void delay_long(unsigned int uiDelaylong);
  14. void T0_time();  //定时中断函数
  15. void key_service(); //按键服务的应用程序
  16. void key_scan(); //按键扫描函数 放在定时中断里
  17. void led_run();  //led灯的应用程序

  18. sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
  19. sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键
  20. sbit key_gnd_dr=P0^4; //模拟独立按键的地GND,因此必须一直输出低电平

  21. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口

  22. sbit led_dr=P3^5;  //LED的驱动IO口


  23. unsigned char ucKeySec=0;   //被触发的按键编号

  24. unsigned int  uiKeyTimeCnt1=0; //按键去抖动延时计数器
  25. unsigned int  uiKeyCtntyCnt1=0;  //按键连续触发的间隔延时计数器
  26. unsigned char ucKeyLock1=0; //按键触发后自锁的变量标志

  27. unsigned int  uiSynCtntyCnt1=0;   //产生按键同步声音的计数器
  28. unsigned int  uiCtntyTimeSet1=const_initial_set; //按键每次触发的时间间隔,这数值不断变小,导致速度不断加快
  29. unsigned int  uiCtntySynSet1=const_initial_set;//同步声音的时间间隔,这数值不断变小,导致速度不断加快
  30. unsigned char ucCtntyFlag1=0;  //是否处于连续加速触发模式的标志位


  31. unsigned int  uiKeyTimeCnt2=0; //按键去抖动延时计数器
  32. unsigned int  uiKeyCtntyCnt2=0;  //按键连续触发的间隔延时计数器
  33. unsigned char ucKeyLock2=0; //按键触发后自锁的变量标志

  34. unsigned int  uiSynCtntyCnt2=0; //产生按键同步声音的计数器
  35. unsigned int  uiCtntyTimeSet2=const_initial_set; //按键每次触发的时间间隔,这数值不断变小,导致速度不断加快
  36. unsigned int  uiCtntySynSet2=const_initial_set; //同步声音的时间间隔,这数值不断变小,导致速度不断加快
  37. unsigned char ucCtntyFlag2=0; //是否处于连续加速触发模式的标志位

  38. unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器

  39. unsigned int  uiSetNumber=0; //设置的数据

  40. void main()
  41.   {
  42.    initial_myself();  
  43.    delay_long(100);   
  44.    initial_peripheral();
  45.    while(1)  
  46.    {
  47.        key_service(); //按键服务的应用程序
  48.        led_run();  //led灯的应用程序
  49.    }

  50. }

  51. void led_run()  //led灯的应用程序
  52. {
  53.    if(uiSetNumber<500)  //如果被设置的参数uiSetNumber小于500,LED灯则灭。否则亮。
  54.    {
  55.       led_dr=0;  //灭
  56.    }
  57.    else
  58.    {
  59.       led_dr=1;  //亮
  60.    }
  61. }


  62. void key_scan()//按键扫描函数 放在定时中断里
  63. {  
  64. /* 注释一:
  65. * 独立按键连续加速扫描的过程:
  66. * 第一步:每次按下去触发一次单击按键,如果按下去到松手的时间不超过1秒,则不会进入连续加速触发模式。
  67. * 第二步:如果按下去不松手的时间超过1秒,则进入连续加速触发模式。按键触发节奏不断加快,蜂鸣器鸣叫的节奏
  68. *         也不断加快。直到它们都到达一个极限值,然后以此极限值间隔匀速触发。在刚开始加速的时候,按键触发与
  69. *         蜂鸣器触发的步骤是一致的,等它们任意一个达到极限值的时候,急促的声音跟按键的触发不一致,并不是
  70. *         蜂鸣器每叫一次,按键就触发一次。实际上加速到最后,按键触发的速度远远比蜂鸣器的触发速度快。
  71. */
  72.   if(key_sr1==1)//IO是高电平,说明按键没有被按下,这时要及时清零一些标志位
  73.   {
  74.      ucKeyLock1=0; //按键自锁标志清零
  75.      uiKeyTimeCnt1=0;//按键去抖动延时计数器清零,此行非常巧妙,是我实战中摸索出来的。   
  76.      uiKeyCtntyCnt1=0; //按键连续加速的时间间隔延时计数器清零
  77.          uiSynCtntyCnt1=0;  //蜂鸣器连续加速的时间间隔延时计数器清零
  78.      uiCtntyTimeSet1=const_initial_set; //按键每次触发的时间间隔初始值,这数值不断变小,导致速度不断加快
  79.      uiCtntySynSet1=const_initial_set; //同步声音的时间间隔初始值,这数值不断变小,导致鸣叫的节奏不断加快

  80.   }
  81.   else if(ucKeyLock1==0)//有按键按下,且是第一次被按下
  82.   {
  83.      uiKeyTimeCnt1++; //累加定时中断次数
  84.      if(uiKeyTimeCnt1>const_key_time1)
  85.      {
  86.         uiKeyTimeCnt1=0;
  87.         ucKeyLock1=1;  //自锁按键置位,避免一直触发
  88.                 ucCtntyFlag1=0; //连续加速触发模式标志位 0代表单击  1代表连续加速触发
  89.         ucKeySec=1;    //触发1号键
  90.      }
  91.   }
  92.   else if(uiKeyTimeCnt1<const_time_1s) //按住累加到1秒
  93.   {
  94.      uiKeyTimeCnt1++;
  95.   }
  96.   else  //按住累加到1秒后仍然不放手,这个时候进入有节奏的连续加速触发
  97.   {
  98.          uiKeyCtntyCnt1++; //按键连续触发延时计数器累加

  99. //按住没松手,每隔一段uiCtntyTimeSet1时间按键就触发一次,而且uiCtntyTimeSet1不断减小,速度就越来越快
  100.          if(uiKeyCtntyCnt1>uiCtntyTimeSet1)
  101.          {
  102.                      if(uiCtntyTimeSet1>const_min_level)
  103.                          {
  104.                             uiCtntyTimeSet1=uiCtntyTimeSet1-const_sub_dt; //uiCtntyTimeSet1不断减小,速度就越来越快
  105.                          }
  106.                          else
  107.                          {
  108.                              uiCtntyTimeSet1=const_last_min_set; //uiCtntyTimeSet1不断减小,到达一个极限值
  109.                          }
  110.              uiKeyCtntyCnt1=0;
  111.                          ucCtntyFlag1=1;  //进入连续加速触发模式
  112.              ucKeySec=1;    //触发1号键
  113.          }


  114.                  uiSynCtntyCnt1++; //蜂鸣器连续触发延时计数器累加

  115. //按住没松手,每隔一段uiCtntySynSet1时间蜂鸣器就触发一次,而且uiCtntySynSet1不断减小,鸣叫的节奏就越来越快
  116.                  if(uiSynCtntyCnt1>uiCtntySynSet1)
  117.                  {
  118.                 uiCtntySynSet1=uiCtntySynSet1-const_sub_dt; //uiCtntySynSet1不断减小,鸣叫的节奏就越来越快
  119.                         if(uiCtntySynSet1<const_syn_min_level)
  120.                         {
  121.                              uiCtntySynSet1=const_syn_min_level; //uiCtntySynSet1不断减小,达到一个极限值
  122.                         }

  123.                         uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  124.                         uiSynCtntyCnt1=0;
  125.                  
  126.                  }


  127.    
  128.   }


  129.   if(key_sr2==1)
  130.   {
  131.      ucKeyLock2=0;
  132.      uiKeyTimeCnt2=0;
  133.      uiKeyCtntyCnt2=0;
  134.          uiSynCtntyCnt2=0;
  135.      uiCtntyTimeSet2=const_initial_set;
  136.      uiCtntySynSet2=const_initial_set;

  137.   }
  138.   else if(ucKeyLock2==0)
  139.   {
  140.      uiKeyTimeCnt2++;
  141.      if(uiKeyTimeCnt2>const_key_time2)
  142.      {
  143.         uiKeyTimeCnt2=0;
  144.         ucKeyLock2=1;  
  145.                 ucCtntyFlag2=0;
  146.         ucKeySec=2;  
  147.      }
  148.   }
  149.   else if(uiKeyTimeCnt2<const_time_1s)
  150.   {
  151.      uiKeyTimeCnt2++;
  152.   }
  153.   else  
  154.   {
  155.          uiKeyCtntyCnt2++;
  156.          if(uiKeyCtntyCnt2>uiCtntyTimeSet2)
  157.          {
  158.                      if(uiCtntyTimeSet2>const_min_level)
  159.                          {
  160.                             uiCtntyTimeSet2=uiCtntyTimeSet2-const_sub_dt;
  161.                          }
  162.                          else
  163.                          {
  164.                              uiCtntyTimeSet2=const_last_min_set;
  165.                          }
  166.              uiKeyCtntyCnt2=0;
  167.                          ucCtntyFlag2=1;
  168.              ucKeySec=2;   
  169.          }

  170.                  uiSynCtntyCnt2++;
  171.                  if(uiSynCtntyCnt2>uiCtntySynSet2)
  172.                  {
  173.                 uiCtntySynSet2=uiCtntySynSet2-const_sub_dt;
  174.                         if(uiCtntySynSet2<const_syn_min_level)
  175.                         {
  176.                              uiCtntySynSet2=const_syn_min_level;
  177.                         }

  178.                         uiVoiceCnt=const_voice_short;
  179.                         uiSynCtntyCnt2=0;
  180.                  
  181.                  }


  182.    
  183.   }
  184. }


  185. void key_service() //第三区 按键服务的应用程序
  186. {
  187.   switch(ucKeySec) //按键服务状态切换
  188.   {
  189.     case 1:// 1号键 连续加键  对应朱兆祺学习板的S1键  
  190.               uiSetNumber++; //被设置的参数连续往上加
  191.               if(uiSetNumber>1000) //最大是1000
  192.               {
  193.                    uiSetNumber=1000;
  194.               }

  195.                           if(ucCtntyFlag1==0) //如果是在单击按键的情况下,则蜂鸣器鸣叫,否则蜂鸣器在按键扫描key_scan里鸣叫
  196.                           {
  197.                   uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  198.                           }
  199.               ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  200.           break;        
  201.     case 2:// 2号键 连续减键  对应朱兆祺学习板的S5键
  202. /* 注释二:
  203. * 在单片机的C语言编译器中,当无符号数据0减去1时,就会溢出,变成这个类型数据的最大值。
  204. * 比如是unsigned int的0减去1就等于65535(0xffff),unsigned char的0减去1就等于255(0xff)
  205. */
  206.               uiSetNumber--; //被设置的参数连续往下减
  207.               if(uiSetNumber>1000) //最小是0.为什么这里用1000?因为0减去1就是溢出变成了65535(0xffff)
  208.               {
  209.                   uiSetNumber=0;
  210.               }
  211.                           if(ucCtntyFlag2==0)  //如果是在单击按键的情况下,则蜂鸣器鸣叫,否则蜂鸣器在按键扫描key_scan里鸣叫
  212.                           {
  213.                   uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  214.                           }
  215.               ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  216.           break;                    
  217.   }               
  218. }



  219. void T0_time() interrupt 1
  220. {
  221.   TF0=0;  //清除中断标志
  222.   TR0=0; //关中断

  223.   key_scan(); //按键扫描函数

  224.   if(uiVoiceCnt!=0)
  225.   {
  226.      uiVoiceCnt--; //每次进入定时中断都自减1,直到等于零为止。才停止鸣叫
  227.          beep_dr=0;  //蜂鸣器是PNP三极管控制,低电平就开始鸣叫。
  228.   }
  229.   else
  230.   {
  231.      ; //此处多加一个空指令,想维持跟if括号语句的数量对称,都是两条指令。不加也可以。
  232.            beep_dr=1;  //蜂鸣器是PNP三极管控制,高电平就停止鸣叫。
  233.   }


  234.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  235.   TL0=0x2f;
  236.   TR0=1;  //开中断
  237. }


  238. void delay_long(unsigned int uiDelayLong)
  239. {
  240.    unsigned int i;
  241.    unsigned int j;
  242.    for(i=0;i<uiDelayLong;i++)
  243.    {
  244.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  245.           {
  246.              ; //一个分号相当于执行一条空语句
  247.           }
  248.    }
  249. }


  250. void initial_myself()  //第一区 初始化单片机
  251. {
  252. /* 注释三:
  253. * 矩阵键盘也可以做独立按键,前提是把某一根公共输出线输出低电平,
  254. * 模拟独立按键的触发地,本程序中,把key_gnd_dr输出低电平。
  255. * 朱兆祺51学习板的S1和S5两个按键就是本程序中用到的两个独立按键。
  256. */
  257.   key_gnd_dr=0; //模拟独立按键的地GND,因此必须一直输出低电平


  258.   beep_dr=1; //用PNP三极管控制蜂鸣器,输出高电平时不叫。
  259.   led_dr=0;  //LED灯灭

  260.   TMOD=0x01;  //设置定时器0为工作方式1


  261.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  262.   TL0=0x2f;

  263. }
  264. void initial_peripheral() //第二区 初始化外围
  265. {
  266.   EA=1;     //开总中断
  267.   ET0=1;    //允许定时中断
  268.   TR0=1;    //启动定时中断

  269. }
复制代码

总结陈词:
    到目前为止,前面一共花了8节内容仔细讲解了独立按键的扫描程序,如果是矩阵键盘,我们该怎么写程序?欲知详情,请听下回分解-----矩阵键盘的单个触发。

(未完待续,下节更精彩,不要走开哦)
此帖出自51单片机论坛

回复

98

帖子

0

TA的资源

一粒金砂(高级)

第十四节:矩阵键盘的单个触发。

开场白:
上一节讲了按键的加速匀速触发。这节开始讲矩阵键盘的单个触发。

具体内容,请看源代码讲解。

(1)硬件平台:基于朱兆祺51单片机学习板。。

(2)实现功能:16个按键中,每按一个按键都能触发一次蜂鸣器发出“滴”的一声。

(3)源代码讲解如下:
  1. #include "REG52.H"

  2. #define const_voice_short  40   //蜂鸣器短叫的持续时间

  3. #define const_key_time  20    //按键去抖动延时的时间

  4. void initial_myself();   
  5. void initial_peripheral();
  6. void delay_long(unsigned int uiDelaylong);
  7. void T0_time();  //定时中断函数
  8. void key_service(); //按键服务的应用程序
  9. void key_scan(); //按键扫描函数 放在定时中断里

  10. sbit key_sr1=P0^0; //第一行输入
  11. sbit key_sr2=P0^1; //第二行输入
  12. sbit key_sr3=P0^2; //第三行输入
  13. sbit key_sr4=P0^3; //第四行输入

  14. sbit key_dr1=P0^4; //第一列输出
  15. sbit key_dr2=P0^5; //第二列输出
  16. sbit key_dr3=P0^6; //第三列输出
  17. sbit key_dr4=P0^7; //第四列输出

  18. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口

  19. unsigned char ucKeyStep=1;  //按键扫描步骤变量

  20. unsigned char ucKeySec=0;   //被触发的按键编号
  21. unsigned int  uiKeyTimeCnt=0; //按键去抖动延时计数器
  22. unsigned char ucKeyLock=0; //按键触发后自锁的变量标志


  23. unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器

  24. void main()
  25.   {
  26.    initial_myself();  
  27.    delay_long(100);   
  28.    initial_peripheral();
  29.    while(1)  
  30.    {
  31.        key_service(); //按键服务的应用程序
  32.    }

  33. }

  34. void key_scan()//按键扫描函数 放在定时中断里
  35. {  
  36. /* 注释一:
  37. *  矩阵按键扫描的详细过程:
  38. *  先输出某一列低电平,其它三列输出高电平,这个时候再分别判断输入的四行,
  39. *  如果发现哪一行是低电平,就说明对应的某个按键被触发。依次分别输出另外三列
  40. *  中的某一列为低电平,再分别判断输入的四行,就可以检测完16个按键。内部详细的
  41. *  去抖动处理方法跟我前面讲的独立按键去抖动方法是一样的。
  42. */

  43.   switch(ucKeyStep)
  44.   {
  45.      case 1:   //按键扫描输出第一列低电平
  46.           key_dr1=0;      
  47.           key_dr2=1;
  48.           key_dr3=1;   
  49.           key_dr4=1;

  50.           uiKeyTimeCnt=0;  //延时计数器清零
  51.           ucKeyStep++;     //切换到下一个运行步骤
  52.               break;

  53.      case 2:     //此处的小延时用来等待刚才列输出信号稳定,再判断输入信号。不是去抖动延时。
  54.           uiKeyTimeCnt++;
  55.                   if(uiKeyTimeCnt>1)
  56.                   {
  57.                      uiKeyTimeCnt=0;
  58.              ucKeyStep++;     //切换到下一个运行步骤
  59.                   }
  60.               break;

  61.      case 3:
  62.           if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==1)
  63.           {  
  64.              ucKeyStep++;  //如果没有按键按下,切换到下一个运行步骤
  65.              ucKeyLock=0;  //按键自锁标志清零
  66.              uiKeyTimeCnt=0; //按键去抖动延时计数器清零,此行非常巧妙        

  67.           }
  68.                   else if(ucKeyLock==0)  //有按键按下,且是第一次触发
  69.                   {
  70.                      if(key_sr1==0&&key_sr2==1&&key_sr3==1&&key_sr4==1)
  71.                          {
  72.                             uiKeyTimeCnt++;  //去抖动延时计数器
  73.                                 if(uiKeyTimeCnt>const_key_time)
  74.                                 {
  75.                                    uiKeyTimeCnt=0;
  76.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  77.                                    ucKeySec=1;  //触发1号键 对应朱兆祺学习板的S1键
  78.                                 }
  79.                         
  80.                          }
  81.                      else if(key_sr1==1&&key_sr2==0&&key_sr3==1&&key_sr4==1)
  82.                          {
  83.                             uiKeyTimeCnt++;  //去抖动延时计数器
  84.                                 if(uiKeyTimeCnt>const_key_time)
  85.                                 {
  86.                                    uiKeyTimeCnt=0;
  87.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  88.                                    ucKeySec=5;  //触发5号键 对应朱兆祺学习板的S5键
  89.                                 }
  90.                         
  91.                          }
  92.                      else if(key_sr1==1&&key_sr2==1&&key_sr3==0&&key_sr4==1)
  93.                          {
  94.                             uiKeyTimeCnt++;  //去抖动延时计数器
  95.                                 if(uiKeyTimeCnt>const_key_time)
  96.                                 {
  97.                                    uiKeyTimeCnt=0;
  98.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  99.                                    ucKeySec=9;  //触发9号键 对应朱兆祺学习板的S9键
  100.                                 }
  101.                         
  102.                          }
  103.                      else if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==0)
  104.                          {
  105.                             uiKeyTimeCnt++;  //去抖动延时计数器
  106.                                 if(uiKeyTimeCnt>const_key_time)
  107.                                 {
  108.                                    uiKeyTimeCnt=0;
  109.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  110.                                    ucKeySec=13;  //触发13号键 对应朱兆祺学习板的S13键
  111.                                 }
  112.                         
  113.                          }
  114.                   
  115.                   }
  116.               break;

  117.      case 4:   //按键扫描输出第二列低电平
  118.           key_dr1=1;      
  119.           key_dr2=0;
  120.           key_dr3=1;   
  121.           key_dr4=1;

  122.           uiKeyTimeCnt=0;  //延时计数器清零
  123.           ucKeyStep++;     //切换到下一个运行步骤
  124.               break;

  125.      case 5:     //此处的小延时用来等待刚才列输出信号稳定,再判断输入信号。不是去抖动延时。
  126.           uiKeyTimeCnt++;
  127.                   if(uiKeyTimeCnt>1)
  128.                   {
  129.                      uiKeyTimeCnt=0;
  130.              ucKeyStep++;     //切换到下一个运行步骤
  131.                   }
  132.               break;

  133.      case 6:
  134.           if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==1)
  135.           {  
  136.              ucKeyStep++;  //如果没有按键按下,切换到下一个运行步骤
  137.              ucKeyLock=0;  //按键自锁标志清零
  138.              uiKeyTimeCnt=0; //按键去抖动延时计数器清零,此行非常巧妙        

  139.           }
  140.                   else if(ucKeyLock==0)  //有按键按下,且是第一次触发
  141.                   {
  142.                      if(key_sr1==0&&key_sr2==1&&key_sr3==1&&key_sr4==1)
  143.                          {
  144.                             uiKeyTimeCnt++;  //去抖动延时计数器
  145.                                 if(uiKeyTimeCnt>const_key_time)
  146.                                 {
  147.                                    uiKeyTimeCnt=0;
  148.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  149.                                    ucKeySec=2;  //触发2号键 对应朱兆祺学习板的S2键
  150.                                 }
  151.                         
  152.                          }
  153.                      else if(key_sr1==1&&key_sr2==0&&key_sr3==1&&key_sr4==1)
  154.                          {
  155.                             uiKeyTimeCnt++;  //去抖动延时计数器
  156.                                 if(uiKeyTimeCnt>const_key_time)
  157.                                 {
  158.                                    uiKeyTimeCnt=0;
  159.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  160.                                    ucKeySec=6;  //触发6号键 对应朱兆祺学习板的S6键
  161.                                 }
  162.                         
  163.                          }
  164.                      else if(key_sr1==1&&key_sr2==1&&key_sr3==0&&key_sr4==1)
  165.                          {
  166.                             uiKeyTimeCnt++;  //去抖动延时计数器
  167.                                 if(uiKeyTimeCnt>const_key_time)
  168.                                 {
  169.                                    uiKeyTimeCnt=0;
  170.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  171.                                    ucKeySec=10;  //触发10号键 对应朱兆祺学习板的S9键
  172.                                 }
  173.                         
  174.                          }
  175.                      else if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==0)
  176.                          {
  177.                             uiKeyTimeCnt++;  //去抖动延时计数器
  178.                                 if(uiKeyTimeCnt>const_key_time)
  179.                                 {
  180.                                    uiKeyTimeCnt=0;
  181.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  182.                                    ucKeySec=14;  //触发14号键 对应朱兆祺学习板的S13键
  183.                                 }
  184.                         
  185.                          }
  186.                   
  187.                   }
  188.               break;

  189.      case 7:   //按键扫描输出第三列低电平
  190.           key_dr1=1;      
  191.           key_dr2=1;
  192.           key_dr3=0;   
  193.           key_dr4=1;

  194.           uiKeyTimeCnt=0;  //延时计数器清零
  195.           ucKeyStep++;     //切换到下一个运行步骤
  196.               break;

  197.      case 8:     //此处的小延时用来等待刚才列输出信号稳定,再判断输入信号。不是去抖动延时。
  198.           uiKeyTimeCnt++;
  199.                   if(uiKeyTimeCnt>1)
  200.                   {
  201.                      uiKeyTimeCnt=0;
  202.              ucKeyStep++;     //切换到下一个运行步骤
  203.                   }
  204.               break;

  205.      case 9:
  206.           if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==1)
  207.           {  
  208.              ucKeyStep++;  //如果没有按键按下,切换到下一个运行步骤
  209.              ucKeyLock=0;  //按键自锁标志清零
  210.              uiKeyTimeCnt=0; //按键去抖动延时计数器清零,此行非常巧妙        

  211.           }
  212.                   else if(ucKeyLock==0)  //有按键按下,且是第一次触发
  213.                   {
  214.                      if(key_sr1==0&&key_sr2==1&&key_sr3==1&&key_sr4==1)
  215.                          {
  216.                             uiKeyTimeCnt++;  //去抖动延时计数器
  217.                                 if(uiKeyTimeCnt>const_key_time)
  218.                                 {
  219.                                    uiKeyTimeCnt=0;
  220.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  221.                                    ucKeySec=3;  //触发3号键 对应朱兆祺学习板的S3键
  222.                                 }
  223.                         
  224.                          }
  225.                      else if(key_sr1==1&&key_sr2==0&&key_sr3==1&&key_sr4==1)
  226.                          {
  227.                             uiKeyTimeCnt++;  //去抖动延时计数器
  228.                                 if(uiKeyTimeCnt>const_key_time)
  229.                                 {
  230.                                    uiKeyTimeCnt=0;
  231.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  232.                                    ucKeySec=7;  //触发7号键 对应朱兆祺学习板的S7键
  233.                                 }
  234.                         
  235.                          }
  236.                      else if(key_sr1==1&&key_sr2==1&&key_sr3==0&&key_sr4==1)
  237.                          {
  238.                             uiKeyTimeCnt++;  //去抖动延时计数器
  239.                                 if(uiKeyTimeCnt>const_key_time)
  240.                                 {
  241.                                    uiKeyTimeCnt=0;
  242.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  243.                                    ucKeySec=11;  //触发11号键 对应朱兆祺学习板的S11键
  244.                                 }
  245.                         
  246.                          }
  247.                      else if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==0)
  248.                          {
  249.                             uiKeyTimeCnt++;  //去抖动延时计数器
  250.                                 if(uiKeyTimeCnt>const_key_time)
  251.                                 {
  252.                                    uiKeyTimeCnt=0;
  253.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  254.                                    ucKeySec=15;  //触发15号键 对应朱兆祺学习板的S15键
  255.                                 }
  256.                         
  257.                          }
  258.                   
  259.                   }
  260.               break;

  261.      case 10:   //按键扫描输出第四列低电平
  262.           key_dr1=1;      
  263.           key_dr2=1;
  264.           key_dr3=1;   
  265.           key_dr4=0;

  266.           uiKeyTimeCnt=0;  //延时计数器清零
  267.           ucKeyStep++;     //切换到下一个运行步骤
  268.               break;

  269.      case 11:     //此处的小延时用来等待刚才列输出信号稳定,再判断输入信号。不是去抖动延时。
  270.           uiKeyTimeCnt++;
  271.                   if(uiKeyTimeCnt>1)
  272.                   {
  273.                      uiKeyTimeCnt=0;
  274.              ucKeyStep++;     //切换到下一个运行步骤
  275.                   }
  276.               break;

  277.      case 12:
  278.           if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==1)
  279.           {  
  280.              ucKeyStep=1;  //如果没有按键按下,返回到第一步,重新开始扫描
  281.              ucKeyLock=0;  //按键自锁标志清零
  282.              uiKeyTimeCnt=0; //按键去抖动延时计数器清零,此行非常巧妙        

  283.           }
  284.                   else if(ucKeyLock==0)  //有按键按下,且是第一次触发
  285.                   {
  286.                      if(key_sr1==0&&key_sr2==1&&key_sr3==1&&key_sr4==1)
  287.                          {
  288.                             uiKeyTimeCnt++;  //去抖动延时计数器
  289.                                 if(uiKeyTimeCnt>const_key_time)
  290.                                 {
  291.                                    uiKeyTimeCnt=0;
  292.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  293.                                    ucKeySec=4;  //触发4号键 对应朱兆祺学习板的S4键
  294.                                 }
  295.                         
  296.                          }
  297.                      else if(key_sr1==1&&key_sr2==0&&key_sr3==1&&key_sr4==1)
  298.                          {
  299.                             uiKeyTimeCnt++;  //去抖动延时计数器
  300.                                 if(uiKeyTimeCnt>const_key_time)
  301.                                 {
  302.                                    uiKeyTimeCnt=0;
  303.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  304.                                    ucKeySec=8;  //触发8号键 对应朱兆祺学习板的S8键
  305.                                 }
  306.                         
  307.                          }
  308.                      else if(key_sr1==1&&key_sr2==1&&key_sr3==0&&key_sr4==1)
  309.                          {
  310.                             uiKeyTimeCnt++;  //去抖动延时计数器
  311.                                 if(uiKeyTimeCnt>const_key_time)
  312.                                 {
  313.                                    uiKeyTimeCnt=0;
  314.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  315.                                    ucKeySec=12;  //触发12号键 对应朱兆祺学习板的S12键
  316.                                 }
  317.                         
  318.                          }
  319.                      else if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==0)
  320.                          {
  321.                             uiKeyTimeCnt++;  //去抖动延时计数器
  322.                                 if(uiKeyTimeCnt>const_key_time)
  323.                                 {
  324.                                    uiKeyTimeCnt=0;
  325.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  326.                                    ucKeySec=16;  //触发16号键 对应朱兆祺学习板的S16键
  327.                                 }
  328.                         
  329.                          }
  330.                   
  331.                   }
  332.               break;

  333.   
  334.   }


  335. }


  336. void key_service() //第三区 按键服务的应用程序
  337. {
  338.   switch(ucKeySec) //按键服务状态切换
  339.   {
  340.     case 1:// 1号键 对应朱兆祺学习板的S1键

  341.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  342.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  343.           break;        
  344.     case 2:// 2号键 对应朱兆祺学习板的S2键

  345.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  346.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  347.           break;     
  348.     case 3:// 3号键 对应朱兆祺学习板的S3键

  349.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  350.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  351.           break;         
  352.     case 4:// 4号键 对应朱兆祺学习板的S4键

  353.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  354.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  355.           break;   
  356.     case 5:// 5号键 对应朱兆祺学习板的S5键

  357.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  358.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  359.           break;   
  360.     case 6:// 6号键 对应朱兆祺学习板的S6键

  361.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  362.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  363.           break;   
  364.     case 7:// 7号键 对应朱兆祺学习板的S7键

  365.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  366.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  367.           break;   
  368.     case 8:// 8号键 对应朱兆祺学习板的S8键

  369.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  370.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  371.           break;   
  372.     case 9:// 9号键 对应朱兆祺学习板的S9键

  373.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  374.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  375.           break;   
  376.     case 10:// 10号键 对应朱兆祺学习板的S10键

  377.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  378.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  379.           break;   
  380.     case 11:// 11号键 对应朱兆祺学习板的S11键

  381.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  382.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  383.           break;   
  384.     case 12:// 12号键 对应朱兆祺学习板的S12键

  385.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  386.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  387.           break;   
  388.     case 13:// 13号键 对应朱兆祺学习板的S13键

  389.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  390.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  391.           break;   
  392.     case 14:// 14号键 对应朱兆祺学习板的S14键

  393.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  394.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  395.           break;   
  396.     case 15:// 15号键 对应朱兆祺学习板的S15键

  397.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  398.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  399.           break;   
  400.     case 16:// 16号键 对应朱兆祺学习板的S16键

  401.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  402.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  403.           break;   
  404.   }               
  405. }



  406. void T0_time() interrupt 1
  407. {
  408.   TF0=0;  //清除中断标志
  409.   TR0=0; //关中断

  410.   key_scan(); //按键扫描函数

  411.   if(uiVoiceCnt!=0)
  412.   {
  413.      uiVoiceCnt--; //每次进入定时中断都自减1,直到等于零为止。才停止鸣叫
  414.          beep_dr=0;  //蜂鸣器是PNP三极管控制,低电平就开始鸣叫。
  415.   }
  416.   else
  417.   {
  418.      ; //此处多加一个空指令,想维持跟if括号语句的数量对称,都是两条指令。不加也可以。
  419.            beep_dr=1;  //蜂鸣器是PNP三极管控制,高电平就停止鸣叫。
  420.   }


  421.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  422.   TL0=0x2f;
  423.   TR0=1;  //开中断
  424. }


  425. void delay_long(unsigned int uiDelayLong)
  426. {
  427.    unsigned int i;
  428.    unsigned int j;
  429.    for(i=0;i<uiDelayLong;i++)
  430.    {
  431.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  432.           {
  433.              ; //一个分号相当于执行一条空语句
  434.           }
  435.    }
  436. }


  437. void initial_myself()  //第一区 初始化单片机
  438. {


  439.   beep_dr=1; //用PNP三极管控制蜂鸣器,输出高电平时不叫。


  440.   TMOD=0x01;  //设置定时器0为工作方式1


  441.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  442.   TL0=0x2f;

  443. }
  444. void initial_peripheral() //第二区 初始化外围
  445. {
  446.   EA=1;     //开总中断
  447.   ET0=1;    //允许定时中断
  448.   TR0=1;    //启动定时中断

  449. }
复制代码

总结陈词:
    在这一节中,有的人咋看我的按键扫描代码,会觉得代码太多了。我一直认为,只要单片机容量够,代码多一点少一点并不重要,只要不影响运行效率就行。而且有时候,代码写多一点,可读性非常强,修改起来也非常方便。如果一味的追求压缩代码,就会刻意用很多循环,数组等元素,代码虽然紧凑了,但是可分离性,可改性,可读性就没那么强。我说那么多并不是因为我技术有限而不懂压缩,就找个借口敷衍大家,不信?我下一节把这节的代码压缩一下分享给大家。凡是相似度高的那部分代码都可以压缩,具体怎么压缩?欲知详情,请听下回分解-----矩阵键盘单个触发的压缩代码编程。

(未完待续,下节更精彩,不要走开哦)
此帖出自51单片机论坛

回复

98

帖子

0

TA的资源

一粒金砂(高级)

第十五节:矩阵键盘单个触发的压缩代码编程。

开场白:
上一节讲了矩阵键盘的单个触发。这节要教会大家在不改变其它任何性能的情况下,把上一节的按键扫描程序压缩一下容量。经过压缩后,把原来1558个字节压缩到860个字节的程序容量。

具体内容,请看源代码讲解。

(1)硬件平台:基于朱兆祺51单片机学习板。。

(2)实现功能:16个按键中,每按一个按键都能触发一次蜂鸣器发出“滴”的一声。

(3)源代码讲解如下:
  1. #include "REG52.H"

  2. #define const_voice_short  40   //蜂鸣器短叫的持续时间

  3. #define const_key_time  20    //按键去抖动延时的时间

  4. void initial_myself();   
  5. void initial_peripheral();
  6. void delay_long(unsigned int uiDelaylong);
  7. void T0_time();  //定时中断函数
  8. void key_service(); //按键服务的应用程序
  9. void key_scan(); //按键扫描函数 放在定时中断里

  10. sbit key_sr1=P0^0; //第一行输入
  11. sbit key_sr2=P0^1; //第二行输入
  12. sbit key_sr3=P0^2; //第三行输入
  13. sbit key_sr4=P0^3; //第四行输入

  14. sbit key_dr1=P0^4; //第一列输出
  15. sbit key_dr2=P0^5; //第二列输出
  16. sbit key_dr3=P0^6; //第三列输出
  17. sbit key_dr4=P0^7; //第四列输出

  18. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口

  19. unsigned char ucKeyStep=1;  //按键扫描步骤变量

  20. unsigned char ucKeySec=0;   //被触发的按键编号
  21. unsigned int  uiKeyTimeCnt=0; //按键去抖动延时计数器
  22. unsigned char ucKeyLock=0; //按键触发后自锁的变量标志

  23. unsigned char ucRowRecord=1; //记录当前扫描到第几列了

  24. unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器

  25. void main()
  26.   {
  27.    initial_myself();  
  28.    delay_long(100);   
  29.    initial_peripheral();
  30.    while(1)  
  31.    {
  32.        key_service(); //按键服务的应用程序
  33.    }

  34. }

  35. void key_scan()//按键扫描函数 放在定时中断里
  36. {  
  37. /* 注释一:
  38. *  矩阵按键扫描的详细过程:
  39. *  先输出某一列低电平,其它三列输出高电平,这个时候再分别判断输入的四行,
  40. *  如果发现哪一行是低电平,就说明对应的某个按键被触发。依次分别输出另外三列
  41. *  中的某一列为低电平,再分别判断输入的四行,就可以检测完16个按键。内部详细的
  42. *  去抖动处理方法跟我前面讲的独立按键去抖动方法是一样的。
  43. */

  44.   switch(ucKeyStep)
  45.   {
  46.      case 1:   //按键扫描输出第ucRowRecord列低电平
  47.               if(ucRowRecord==1)  //第一列输出低电平
  48.                   {
  49.              key_dr1=0;      
  50.              key_dr2=1;
  51.              key_dr3=1;   
  52.              key_dr4=1;
  53.                   }
  54.               else if(ucRowRecord==2)  //第二列输出低电平
  55.                   {
  56.              key_dr1=1;      
  57.              key_dr2=0;
  58.              key_dr3=1;   
  59.              key_dr4=1;
  60.                   }
  61.               else if(ucRowRecord==3)  //第三列输出低电平
  62.                   {
  63.              key_dr1=1;      
  64.              key_dr2=1;
  65.              key_dr3=0;   
  66.              key_dr4=1;
  67.                   }
  68.               else   //第四列输出低电平
  69.                   {
  70.              key_dr1=1;      
  71.              key_dr2=1;
  72.              key_dr3=1;   
  73.              key_dr4=0;
  74.                   }

  75.           uiKeyTimeCnt=0;  //延时计数器清零
  76.           ucKeyStep++;     //切换到下一个运行步骤
  77.               break;

  78.      case 2:     //此处的小延时用来等待刚才列输出信号稳定,再判断输入信号。不是去抖动延时。
  79.           uiKeyTimeCnt++;
  80.                   if(uiKeyTimeCnt>1)
  81.                   {
  82.                      uiKeyTimeCnt=0;
  83.              ucKeyStep++;     //切换到下一个运行步骤
  84.                   }
  85.               break;

  86.      case 3:
  87.           if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==1)
  88.           {  
  89.              ucKeyStep=1;  //如果没有按键按下,返回到第一个运行步骤重新开始扫描
  90.              ucKeyLock=0;  //按键自锁标志清零
  91.              uiKeyTimeCnt=0; //按键去抖动延时计数器清零,此行非常巧妙     
  92.    
  93.                          ucRowRecord++;  //输出下一列
  94.                          if(ucRowRecord>4)  
  95.                          {
  96.                             ucRowRecord=1; //依次输出完四列之后,继续从第一列开始输出低电平
  97.                          }

  98.           }
  99.                   else if(ucKeyLock==0)  //有按键按下,且是第一次触发
  100.                   {
  101.                      if(key_sr1==0&&key_sr2==1&&key_sr3==1&&key_sr4==1)
  102.                          {
  103.                             uiKeyTimeCnt++;  //去抖动延时计数器
  104.                                 if(uiKeyTimeCnt>const_key_time)
  105.                                 {
  106.                                    uiKeyTimeCnt=0;
  107.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零

  108.                        if(ucRowRecord==1)  //第一列输出低电平
  109.                            {
  110.                                       ucKeySec=1;  //触发1号键 对应朱兆祺学习板的S1键
  111.                            }
  112.                        else if(ucRowRecord==2)  //第二列输出低电平
  113.                            {
  114.                                       ucKeySec=2;  //触发2号键 对应朱兆祺学习板的S2键
  115.                            }
  116.                        else if(ucRowRecord==3)  //第三列输出低电平
  117.                            {
  118.                                       ucKeySec=3;  //触发3号键 对应朱兆祺学习板的S3键
  119.                            }
  120.                        else   //第四列输出低电平
  121.                            {
  122.                                       ucKeySec=4;  //触发4号键 对应朱兆祺学习板的S4键
  123.                            }

  124.                                 }
  125.                         
  126.                          }
  127.                      else if(key_sr1==1&&key_sr2==0&&key_sr3==1&&key_sr4==1)
  128.                          {
  129.                             uiKeyTimeCnt++;  //去抖动延时计数器
  130.                                 if(uiKeyTimeCnt>const_key_time)
  131.                                 {
  132.                                    uiKeyTimeCnt=0;
  133.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  134.                        if(ucRowRecord==1)  //第一列输出低电平
  135.                            {
  136.                                       ucKeySec=5;  //触发5号键 对应朱兆祺学习板的S5键
  137.                            }
  138.                        else if(ucRowRecord==2)  //第二列输出低电平
  139.                            {
  140.                                       ucKeySec=6;  //触发6号键 对应朱兆祺学习板的S6键
  141.                            }
  142.                        else if(ucRowRecord==3)  //第三列输出低电平
  143.                            {
  144.                                       ucKeySec=7;  //触发7号键 对应朱兆祺学习板的S7键
  145.                            }
  146.                        else   //第四列输出低电平
  147.                            {
  148.                                       ucKeySec=8;  //触发8号键 对应朱兆祺学习板的S8键
  149.                            }
  150.                                 }
  151.                         
  152.                          }
  153.                      else if(key_sr1==1&&key_sr2==1&&key_sr3==0&&key_sr4==1)
  154.                          {
  155.                             uiKeyTimeCnt++;  //去抖动延时计数器
  156.                                 if(uiKeyTimeCnt>const_key_time)
  157.                                 {
  158.                                    uiKeyTimeCnt=0;
  159.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  160.                        if(ucRowRecord==1)  //第一列输出低电平
  161.                            {
  162.                                       ucKeySec=9;  //触发9号键 对应朱兆祺学习板的S9键
  163.                            }
  164.                        else if(ucRowRecord==2)  //第二列输出低电平
  165.                            {
  166.                                       ucKeySec=10;  //触发10号键 对应朱兆祺学习板的S10键
  167.                            }
  168.                        else if(ucRowRecord==3)  //第三列输出低电平
  169.                            {
  170.                                       ucKeySec=11;  //触发11号键 对应朱兆祺学习板的S11键
  171.                            }
  172.                        else   //第四列输出低电平
  173.                            {
  174.                                       ucKeySec=12;  //触发12号键 对应朱兆祺学习板的S12键
  175.                            }
  176.                                 }
  177.                         
  178.                          }
  179.                      else if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==0)
  180.                          {
  181.                             uiKeyTimeCnt++;  //去抖动延时计数器
  182.                                 if(uiKeyTimeCnt>const_key_time)
  183.                                 {
  184.                                    uiKeyTimeCnt=0;
  185.                                    ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
  186.                        if(ucRowRecord==1)  //第一列输出低电平
  187.                            {
  188.                                       ucKeySec=13;  //触发13号键 对应朱兆祺学习板的S13键
  189.                            }
  190.                        else if(ucRowRecord==2)  //第二列输出低电平
  191.                            {
  192.                                       ucKeySec=14;  //触发14号键 对应朱兆祺学习板的S14键
  193.                            }
  194.                        else if(ucRowRecord==3)  //第三列输出低电平
  195.                            {
  196.                                       ucKeySec=15;  //触发15号键 对应朱兆祺学习板的S15键
  197.                            }
  198.                        else   //第四列输出低电平
  199.                            {
  200.                                       ucKeySec=16;  //触发16号键 对应朱兆祺学习板的S16键
  201.                            }
  202.                                 }
  203.                         
  204.                          }
  205.                   
  206.                   }
  207.               break;

  208.   }


  209. }


  210. void key_service() //第三区 按键服务的应用程序
  211. {
  212.   switch(ucKeySec) //按键服务状态切换
  213.   {
  214.     case 1:// 1号键 对应朱兆祺学习板的S1键

  215.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  216.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  217.           break;        
  218.     case 2:// 2号键 对应朱兆祺学习板的S2键

  219.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  220.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  221.           break;     
  222.     case 3:// 3号键 对应朱兆祺学习板的S3键

  223.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  224.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  225.           break;         
  226.     case 4:// 4号键 对应朱兆祺学习板的S4键

  227.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  228.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  229.           break;   
  230.     case 5:// 5号键 对应朱兆祺学习板的S5键

  231.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  232.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  233.           break;   
  234.     case 6:// 6号键 对应朱兆祺学习板的S6键

  235.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  236.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  237.           break;   
  238.     case 7:// 7号键 对应朱兆祺学习板的S7键

  239.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  240.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  241.           break;   
  242.     case 8:// 8号键 对应朱兆祺学习板的S8键

  243.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  244.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  245.           break;   
  246.     case 9:// 9号键 对应朱兆祺学习板的S9键

  247.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  248.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  249.           break;   
  250.     case 10:// 10号键 对应朱兆祺学习板的S10键

  251.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  252.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  253.           break;   
  254.     case 11:// 11号键 对应朱兆祺学习板的S11键

  255.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  256.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  257.           break;   
  258.     case 12:// 12号键 对应朱兆祺学习板的S12键

  259.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  260.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  261.           break;   
  262.     case 13:// 13号键 对应朱兆祺学习板的S13键

  263.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  264.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  265.           break;   
  266.     case 14:// 14号键 对应朱兆祺学习板的S14键

  267.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  268.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  269.           break;   
  270.     case 15:// 15号键 对应朱兆祺学习板的S15键

  271.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  272.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  273.           break;   
  274.     case 16:// 16号键 对应朱兆祺学习板的S16键

  275.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  276.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  277.           break;   
  278.   }               
  279. }



  280. void T0_time() interrupt 1
  281. {
  282.   TF0=0;  //清除中断标志
  283.   TR0=0; //关中断

  284.   key_scan(); //按键扫描函数

  285.   if(uiVoiceCnt!=0)
  286.   {
  287.      uiVoiceCnt--; //每次进入定时中断都自减1,直到等于零为止。才停止鸣叫
  288.          beep_dr=0;  //蜂鸣器是PNP三极管控制,低电平就开始鸣叫。
  289.   }
  290.   else
  291.   {
  292.      ; //此处多加一个空指令,想维持跟if括号语句的数量对称,都是两条指令。不加也可以。
  293.            beep_dr=1;  //蜂鸣器是PNP三极管控制,高电平就停止鸣叫。
  294.   }


  295.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  296.   TL0=0x2f;
  297.   TR0=1;  //开中断
  298. }


  299. void delay_long(unsigned int uiDelayLong)
  300. {
  301.    unsigned int i;
  302.    unsigned int j;
  303.    for(i=0;i<uiDelayLong;i++)
  304.    {
  305.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  306.           {
  307.              ; //一个分号相当于执行一条空语句
  308.           }
  309.    }
  310. }


  311. void initial_myself()  //第一区 初始化单片机
  312. {


  313.   beep_dr=1; //用PNP三极管控制蜂鸣器,输出高电平时不叫。


  314.   TMOD=0x01;  //设置定时器0为工作方式1


  315.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  316.   TL0=0x2f;

  317. }
  318. void initial_peripheral() //第二区 初始化外围
  319. {
  320.   EA=1;     //开总中断
  321.   ET0=1;    //允许定时中断
  322.   TR0=1;    //启动定时中断

  323. }
复制代码

总结陈词:
    已经花了两节讲矩阵键盘的单个触发程序。那么,矩阵键盘可不可以实现类似独立按键的组合按键功能?当然可以,但是也有一些附加限制条件。欲知详情,请听下回分解-----矩阵键盘的组合按键触发。

(未完待续,下节更精彩,不要走开哦)
此帖出自51单片机论坛

回复

98

帖子

0

TA的资源

一粒金砂(高级)

第十六节:矩阵键盘的组合按键触发。

开场白:
上一节讲了矩阵键盘单个触发的压缩代码编程。这节讲矩阵键盘的组合按键触发。要教会大家三个知识点:
第一点:如何把矩阵键盘翻译成独立按盘的处理方式。然后按独立按键的方式来实现组合按键的功能。
第二点:要提醒大家在设计矩阵键盘时,很容易犯的一个错误。任意两个组合按键不能处于同一行,否则触发性能大打折扣。在做产品的时候,硬件电路设计中,除了四路行输入的要加上拉电阻,四路列输出也应该串入一个470欧左右的限流电阻,否则当同一行的两个按键同时按下时,很容易烧坏单片机IO口。为什么?大家仔细想想原因。因为如果没有限流电阻,同一行的两个按键同时按下时,在某一瞬间,输出的两路高低电平将会直接短接在一起,引起短路。在朱兆祺的学习板中,S1至S4是同一行,S5至S8是同一行,S9至S12是同一行,S13至S16是同一行。
第三点:在鸿哥矩阵键盘的组合按键处理程序中,组合按键的去抖动延时const_key_time_comb千万不能等于单击按键的去抖动延时const_key_time,否则组合按键会覆盖单击按键的触发。

具体内容,请看源代码讲解。

(1)硬件平台:基于朱兆祺51单片机学习板。

(2)实现功能:16个按键中,每按一个按键都能触发一次蜂鸣器发出“滴”的一声。在同时按下S1和S16按键时,将会点亮一个LED灯。在同时按下S4和S13按键时,将会熄灭一个LED灯。

(3)源代码讲解如下:
  1. #include "REG52.H"

  2. #define const_voice_short  40   //蜂鸣器短叫的持续时间


  3. /* 注释一:
  4. *  注意:组合按键的去抖动延时const_key_time_comb千万不能等于单击按键
  5. *  的去抖动延时const_key_time,否则组合按键会覆盖单击按键的触发。
  6. */
  7. #define const_key_time  12    //按键去抖动延时的时间
  8. #define const_key_time_comb  14    //组合按键去抖动延时的时间

  9. void initial_myself();   
  10. void initial_peripheral();
  11. void delay_long(unsigned int uiDelaylong);
  12. void T0_time();  //定时中断函数
  13. void key_service(); //按键服务的应用程序
  14. void key_scan(); //按键扫描函数 放在定时中断里

  15. /* 注释二:
  16. *  注意:任意两个组合按键不能处于同一行,否则触发性能大打折扣。
  17. *  在做产品的时候,硬件电路设计中,除了四路行输入的要加上拉电阻,
  18. *  四路列输出也应该串入一个470欧左右的限流电阻,否则当同一行的两个
  19. *  按键同时按下时,很容易烧坏单片机IO口。为什么?大家仔细想想原因。
  20. *  因为如果没有限流电阻,同一行的两个按键同时按下时,在某一瞬间,
  21. *  输出的两路高低电平将会直接短接在一起,引起短路。
  22. *  在朱兆祺的学习板中,S1至S4是同一行,S5至S8是同一行,S9至S12是同一行,S13至S16是同一行。
  23. */
  24. sbit key_sr1=P0^0; //第一行输入
  25. sbit key_sr2=P0^1; //第二行输入
  26. sbit key_sr3=P0^2; //第三行输入
  27. sbit key_sr4=P0^3; //第四行输入

  28. sbit key_dr1=P0^4; //第一列输出
  29. sbit key_dr2=P0^5; //第二列输出
  30. sbit key_dr3=P0^6; //第三列输出
  31. sbit key_dr4=P0^7; //第四列输出

  32. sbit led_dr=P3^5;  //LED灯的输出

  33. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口

  34. unsigned char ucKeyStep=1;  //按键扫描步骤变量

  35. unsigned char ucKeySec=0;   //被触发的按键编号

  36. unsigned int  uiKeyTimeCnt[16]=0; //16个按键去抖动延时计数器
  37. unsigned char ucKeyLock[16]=0; //16个按键触发后自锁的变量标志

  38. unsigned int  uiKeyTimeCnt_01_16=0; //S1和S16组合按键去抖动延时计数器
  39. unsigned char ucKeyLock_01_16=0; //S1和S16组合按键触发后自锁的变量标志

  40. unsigned int  uiKeyTimeCnt_04_13=0; //S4和S13组合按键去抖动延时计数器
  41. unsigned char ucKeyLock_04_13=0; //S4和S13组合按键触发后自锁的变量标志

  42. unsigned char ucRowRecord=1; //记录当前扫描到第几列了

  43. unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器

  44. unsigned int  uiKeyStatus=0xffff;  //此变量每一位代表一个按键的状态,共16个按键。1代表没有被按下,0代表被按下。

  45. void main()
  46.   {
  47.    initial_myself();  
  48.    delay_long(100);   
  49.    initial_peripheral();
  50.    while(1)  
  51.    {
  52.        key_service(); //按键服务的应用程序
  53.    }

  54. }

  55. void key_scan()//按键扫描函数 放在定时中断里
  56. {  
  57. /* 注释三:
  58. *  第一步:先把16个按键翻译成独立按键。
  59. *  第二步: 再按独立按键的去抖动方式进行按键识别。
  60. *  第三步: 本程序把矩阵键盘翻译成独立按键的处理方式后,大家可以按独立按键的方式
  61. *          来实现组合按键,双击,长按和短按,按住连续触发等功能。
  62. *          我本人不再详细介绍这方面的内容。有兴趣的朋友,可以参考一下我前面章节讲的独立按键。
  63. */

  64.   switch(ucKeyStep)
  65.   {
  66.      case 1:   //把16个按键的状态快速记录在uiKeyStatus变量的每一位中,相当于把矩阵键盘翻译成独立按键。
  67.               for(ucRowRecord=1;ucRowRecord<5;ucRowRecord++)
  68.                     {
  69.                  if(ucRowRecord==1)  //第一列输出低电平
  70.                      {
  71.                key_dr1=0;      
  72.                key_dr2=1;
  73.                key_dr3=1;   
  74.                key_dr4=1;
  75.                 //如果是薄膜按键或者走线比较长的按键,此处应该加几个空延时,等待列输出信号稳定再判断输入的状态
  76.                        if(key_sr1==0)
  77.                            {
  78.                               uiKeyStatus=uiKeyStatus&0xfffe; //对应朱兆祺学习板的S1键被按下
  79.                            }
  80.                        if(key_sr2==0)
  81.                            {
  82.                               uiKeyStatus=uiKeyStatus&0xffef; //对应朱兆祺学习板的S5键被按下
  83.                            }
  84.                        if(key_sr3==0)
  85.                            {
  86.                               uiKeyStatus=uiKeyStatus&0xfeff; //对应朱兆祺学习板的S9键被按下
  87.                            }
  88.                        if(key_sr4==0)
  89.                            {
  90.                               uiKeyStatus=uiKeyStatus&0xefff; //对应朱兆祺学习板的S13键被按下
  91.                            }
  92.                      }
  93.                  else if(ucRowRecord==2)  //第二列输出低电平
  94.                      {
  95.                 key_dr1=1;      
  96.                 key_dr2=0;
  97.                 key_dr3=1;   
  98.                 key_dr4=1;
  99.                 //如果是薄膜按键或者走线比较长的按键,此处应该加几个空延时,等待列输出信号稳定再判断输入的状态
  100.                         if(key_sr1==0)
  101.                               {
  102.                               uiKeyStatus=uiKeyStatus&0xfffd; //对应朱兆祺学习板的S2键被按下
  103.                              }
  104.                         if(key_sr2==0)
  105.                             {
  106.                               uiKeyStatus=uiKeyStatus&0xffdf; //对应朱兆祺学习板的S6键被按下
  107.                             }
  108.                         if(key_sr3==0)
  109.                             {
  110.                                uiKeyStatus=uiKeyStatus&0xfdff; //对应朱兆祺学习板的S10键被按下
  111.                             }
  112.                         if(key_sr4==0)
  113.                             {
  114.                                uiKeyStatus=uiKeyStatus&0xdfff; //对应朱兆祺学习板的S14键被按下
  115.                               }
  116.                      }
  117.                  else if(ucRowRecord==3)  //第三列输出低电平
  118.                      {
  119.                 key_dr1=1;      
  120.                 key_dr2=1;
  121.                 key_dr3=0;   
  122.                 key_dr4=1;
  123.                  //如果是薄膜按键或者走线比较长的按键,此处应该加几个空延时,等待列输出信号稳定再判断输入的状态
  124.                         if(key_sr1==0)
  125.                             {
  126.                                uiKeyStatus=uiKeyStatus&0xfffb; //对应朱兆祺学习板的S3键被按下
  127.                             }
  128.                         if(key_sr2==0)
  129.                             {
  130.                                uiKeyStatus=uiKeyStatus&0xffbf; //对应朱兆祺学习板的S7键被按下
  131.                             }
  132.                         if(key_sr3==0)
  133.                             {
  134.                                uiKeyStatus=uiKeyStatus&0xfbff; //对应朱兆祺学习板的S11键被按下
  135.                               }
  136.                         if(key_sr4==0)
  137.                             {
  138.                                uiKeyStatus=uiKeyStatus&0xbfff; //对应朱兆祺学习板的S15键被按下
  139.                             }
  140.                      }
  141.                  else   //第四列输出低电平
  142.                      {
  143.                 key_dr1=1;      
  144.                 key_dr2=1;
  145.                 key_dr3=1;   
  146.                 key_dr4=0;
  147.                  //如果是薄膜按键或者走线比较长的按键,此处应该加几个空延时,等待列输出信号稳定再判断输入的状态
  148.                         if(key_sr1==0)
  149.                              {
  150.                                uiKeyStatus=uiKeyStatus&0xfff7; //对应朱兆祺学习板的S4键被按下
  151.                             }
  152.                         if(key_sr2==0)
  153.                             {
  154.                                uiKeyStatus=uiKeyStatus&0xff7f; //对应朱兆祺学习板的S8键被按下
  155.                             }
  156.                         if(key_sr3==0)
  157.                             {
  158.                                uiKeyStatus=uiKeyStatus&0xf7ff; //对应朱兆祺学习板的S12键被按下
  159.                             }
  160.                         if(key_sr4==0)
  161.                             {
  162.                                uiKeyStatus=uiKeyStatus&0x7fff; //对应朱兆祺学习板的S16键被按下
  163.                             }
  164.                      }
  165.           }

  166.           ucKeyStep=2;     //切换到下一个运行步骤
  167.               break;

  168.      case 2:  //像独立按键一样进行去抖动和翻译。以下代码相似度很高,大家有兴趣的话还可以加for循环来压缩代码
  169.               if((uiKeyStatus&0x0001)==0x0001)  //说明1号键没有被按下来
  170.                   {
  171.              uiKeyTimeCnt[0]=0;
  172.              ucKeyLock[0]=0;
  173.                   }
  174.                   else if(ucKeyLock[0]==0)
  175.                   {
  176.                      uiKeyTimeCnt[0]++;
  177.                          if(uiKeyTimeCnt[0]>const_key_time)
  178.                          {
  179.                             uiKeyTimeCnt[0]=0;
  180.                             ucKeyLock[0]=1; //自锁按键,防止不断触发
  181.                             ucKeySec=1;   //被触发1号键
  182.                          }
  183.                   }

  184.               if((uiKeyStatus&0x0002)==0x0002)  //说明2号键没有被按下来
  185.                   {
  186.              uiKeyTimeCnt[1]=0;
  187.              ucKeyLock[1]=0;
  188.                   }
  189.                   else if(ucKeyLock[1]==0)
  190.                   {
  191.                      uiKeyTimeCnt[1]++;
  192.                          if(uiKeyTimeCnt[1]>const_key_time)
  193.                          {
  194.                             uiKeyTimeCnt[1]=0;
  195.                             ucKeyLock[1]=1; //自锁按键,防止不断触发
  196.                             ucKeySec=2;   //被触发2号键
  197.                          }
  198.                   }

  199.               if((uiKeyStatus&0x0004)==0x0004)  //说明3号键没有被按下来
  200.                   {
  201.              uiKeyTimeCnt[2]=0;
  202.              ucKeyLock[2]=0;
  203.                   }
  204.                   else if(ucKeyLock[2]==0)
  205.                   {
  206.                      uiKeyTimeCnt[2]++;
  207.                          if(uiKeyTimeCnt[2]>const_key_time)
  208.                          {
  209.                             uiKeyTimeCnt[2]=0;
  210.                             ucKeyLock[2]=1; //自锁按键,防止不断触发
  211.                             ucKeySec=3;   //被触发3号键
  212.                          }
  213.                   }

  214.               if((uiKeyStatus&0x0008)==0x0008)  //说明4号键没有被按下来
  215.                   {
  216.              uiKeyTimeCnt[3]=0;
  217.              ucKeyLock[3]=0;
  218.                   }
  219.                   else if(ucKeyLock[3]==0)
  220.                   {
  221.                      uiKeyTimeCnt[3]++;
  222.                          if(uiKeyTimeCnt[3]>const_key_time)
  223.                          {
  224.                             uiKeyTimeCnt[3]=0;
  225.                             ucKeyLock[3]=1; //自锁按键,防止不断触发
  226.                             ucKeySec=4;   //被触发4号键
  227.                          }
  228.                   }

  229.               if((uiKeyStatus&0x0010)==0x0010)  //说明5号键没有被按下来
  230.                   {
  231.              uiKeyTimeCnt[4]=0;
  232.              ucKeyLock[4]=0;
  233.                   }
  234.                   else if(ucKeyLock[4]==0)
  235.                   {
  236.                      uiKeyTimeCnt[4]++;
  237.                          if(uiKeyTimeCnt[4]>const_key_time)
  238.                          {
  239.                             uiKeyTimeCnt[4]=0;
  240.                             ucKeyLock[4]=1; //自锁按键,防止不断触发
  241.                             ucKeySec=5;   //被触发5号键
  242.                          }
  243.                   }

  244.               if((uiKeyStatus&0x0020)==0x0020)  //说明6号键没有被按下来
  245.                   {
  246.              uiKeyTimeCnt[5]=0;
  247.              ucKeyLock[5]=0;
  248.                   }
  249.                   else if(ucKeyLock[5]==0)
  250.                   {
  251.                      uiKeyTimeCnt[5]++;
  252.                          if(uiKeyTimeCnt[5]>const_key_time)
  253.                          {
  254.                             uiKeyTimeCnt[5]=0;
  255.                             ucKeyLock[5]=1; //自锁按键,防止不断触发
  256.                             ucKeySec=6;   //被触发6号键
  257.                          }
  258.                   }

  259.               if((uiKeyStatus&0x0040)==0x0040)  //说明7号键没有被按下来
  260.                   {
  261.              uiKeyTimeCnt[6]=0;
  262.              ucKeyLock[6]=0;
  263.                   }
  264.                   else if(ucKeyLock[6]==0)
  265.                   {
  266.                      uiKeyTimeCnt[6]++;
  267.                          if(uiKeyTimeCnt[6]>const_key_time)
  268.                          {
  269.                             uiKeyTimeCnt[6]=0;
  270.                             ucKeyLock[6]=1; //自锁按键,防止不断触发
  271.                             ucKeySec=7;   //被触发7号键
  272.                          }
  273.                   }

  274.               if((uiKeyStatus&0x0080)==0x0080)  //说明8号键没有被按下来
  275.                   {
  276.              uiKeyTimeCnt[7]=0;
  277.              ucKeyLock[7]=0;
  278.                   }
  279.                   else if(ucKeyLock[7]==0)
  280.                   {
  281.                      uiKeyTimeCnt[7]++;
  282.                          if(uiKeyTimeCnt[7]>const_key_time)
  283.                          {
  284.                             uiKeyTimeCnt[7]=0;
  285.                             ucKeyLock[7]=1; //自锁按键,防止不断触发
  286.                             ucKeySec=8;   //被触发8号键
  287.                          }
  288.                   }

  289.               if((uiKeyStatus&0x0100)==0x0100)  //说明9号键没有被按下来
  290.                   {
  291.              uiKeyTimeCnt[8]=0;
  292.              ucKeyLock[8]=0;
  293.                   }
  294.                   else if(ucKeyLock[8]==0)
  295.                   {
  296.                      uiKeyTimeCnt[8]++;
  297.                          if(uiKeyTimeCnt[8]>const_key_time)
  298.                          {
  299.                             uiKeyTimeCnt[8]=0;
  300.                             ucKeyLock[8]=1; //自锁按键,防止不断触发
  301.                             ucKeySec=9;   //被触发9号键
  302.                          }
  303.                   }

  304.               if((uiKeyStatus&0x0200)==0x0200)  //说明10号键没有被按下来
  305.                   {
  306.              uiKeyTimeCnt[9]=0;
  307.              ucKeyLock[9]=0;
  308.                   }
  309.                   else if(ucKeyLock[9]==0)
  310.                   {
  311.                      uiKeyTimeCnt[9]++;
  312.                          if(uiKeyTimeCnt[9]>const_key_time)
  313.                          {
  314.                             uiKeyTimeCnt[9]=0;
  315.                             ucKeyLock[9]=1; //自锁按键,防止不断触发
  316.                             ucKeySec=10;   //被触发10号键
  317.                          }
  318.                   }

  319.               if((uiKeyStatus&0x0400)==0x0400)  //说明11号键没有被按下来
  320.                   {
  321.              uiKeyTimeCnt[10]=0;
  322.              ucKeyLock[10]=0;
  323.                   }
  324.                   else if(ucKeyLock[10]==0)
  325.                   {
  326.                      uiKeyTimeCnt[10]++;
  327.                          if(uiKeyTimeCnt[10]>const_key_time)
  328.                          {
  329.                             uiKeyTimeCnt[10]=0;
  330.                             ucKeyLock[10]=1; //自锁按键,防止不断触发
  331.                             ucKeySec=11;   //被触发11号键
  332.                          }
  333.                   }

  334.               if((uiKeyStatus&0x0800)==0x0800)  //说明12号键没有被按下来
  335.                   {
  336.              uiKeyTimeCnt[11]=0;
  337.              ucKeyLock[11]=0;
  338.                   }
  339.                   else if(ucKeyLock[11]==0)
  340.                   {
  341.                      uiKeyTimeCnt[11]++;
  342.                          if(uiKeyTimeCnt[11]>const_key_time)
  343.                          {
  344.                             uiKeyTimeCnt[11]=0;
  345.                             ucKeyLock[11]=1; //自锁按键,防止不断触发
  346.                             ucKeySec=12;   //被触发12号键
  347.                          }
  348.                   }

  349.               if((uiKeyStatus&0x0800)==0x0800)  //说明12号键没有被按下来
  350.                   {
  351.              uiKeyTimeCnt[11]=0;
  352.              ucKeyLock[11]=0;
  353.                   }
  354.                   else if(ucKeyLock[11]==0)
  355.                   {
  356.                      uiKeyTimeCnt[11]++;
  357.                          if(uiKeyTimeCnt[11]>const_key_time)
  358.                          {
  359.                             uiKeyTimeCnt[11]=0;
  360.                             ucKeyLock[11]=1; //自锁按键,防止不断触发
  361.                             ucKeySec=12;   //被触发12号键
  362.                          }
  363.                   }

  364.               if((uiKeyStatus&0x1000)==0x1000)  //说明13号键没有被按下来
  365.                   {
  366.              uiKeyTimeCnt[12]=0;
  367.              ucKeyLock[12]=0;
  368.                   }
  369.                   else if(ucKeyLock[12]==0)
  370.                   {
  371.                      uiKeyTimeCnt[12]++;
  372.                          if(uiKeyTimeCnt[12]>const_key_time)
  373.                          {
  374.                             uiKeyTimeCnt[12]=0;
  375.                             ucKeyLock[12]=1; //自锁按键,防止不断触发
  376.                             ucKeySec=13;   //被触发13号键
  377.                          }
  378.                   }


  379.               if((uiKeyStatus&0x2000)==0x2000)  //说明14号键没有被按下来
  380.                   {
  381.              uiKeyTimeCnt[13]=0;
  382.              ucKeyLock[13]=0;
  383.                   }
  384.                   else if(ucKeyLock[13]==0)
  385.                   {
  386.                      uiKeyTimeCnt[13]++;
  387.                          if(uiKeyTimeCnt[13]>const_key_time)
  388.                          {
  389.                             uiKeyTimeCnt[13]=0;
  390.                             ucKeyLock[13]=1; //自锁按键,防止不断触发
  391.                             ucKeySec=14;   //被触发14号键
  392.                          }
  393.                   }

  394.               if((uiKeyStatus&0x4000)==0x4000)  //说明15号键没有被按下来
  395.                   {
  396.              uiKeyTimeCnt[14]=0;
  397.              ucKeyLock[14]=0;
  398.                   }
  399.                   else if(ucKeyLock[14]==0)
  400.                   {
  401.                      uiKeyTimeCnt[14]++;
  402.                          if(uiKeyTimeCnt[14]>const_key_time)
  403.                          {
  404.                             uiKeyTimeCnt[14]=0;
  405.                             ucKeyLock[14]=1; //自锁按键,防止不断触发
  406.                             ucKeySec=15;   //被触发15号键
  407.                          }
  408.                   }

  409.               if((uiKeyStatus&0x8000)==0x8000)  //说明16号键没有被按下来
  410.                   {
  411.              uiKeyTimeCnt[15]=0;
  412.              ucKeyLock[15]=0;
  413.                   }
  414.                   else if(ucKeyLock[15]==0)
  415.                   {
  416.                      uiKeyTimeCnt[15]++;
  417.                          if(uiKeyTimeCnt[15]>const_key_time)
  418.                          {
  419.                             uiKeyTimeCnt[15]=0;
  420.                             ucKeyLock[15]=1; //自锁按键,防止不断触发
  421.                             ucKeySec=16;   //被触发16号键
  422.                          }
  423.                   }


  424.               if((uiKeyStatus&0x8001)==0x0000)  //S1和S16的组合键盘被按下。
  425.                   {
  426.              if(ucKeyLock_01_16==0)
  427.                          {
  428.                              uiKeyTimeCnt_01_16++;
  429.                                  if(uiKeyTimeCnt_01_16>const_key_time_comb)
  430.                                  {
  431.                                     uiKeyTimeCnt_01_16=0;
  432.                                         ucKeyLock_01_16=1;
  433.                                         ucKeySec=17;   //被触发17号组合键                           
  434.                                  }
  435.                              
  436.                          }
  437.                   }
  438.                   else
  439.                   {
  440.              uiKeyTimeCnt_01_16=0; //S1和S16组合按键去抖动延时计数器
  441.              ucKeyLock_01_16=0; //S1和S16组合按键触发后自锁的变量标志
  442.                   }


  443.               if((uiKeyStatus&0x1008)==0x0000)  //S4和S13的组合键盘被按下。
  444.                   {
  445.              if(ucKeyLock_04_13==0)
  446.                          {
  447.                              uiKeyTimeCnt_04_13++;
  448.                                  if(uiKeyTimeCnt_04_13>const_key_time_comb)
  449.                                  {
  450.                                     uiKeyTimeCnt_04_13=0;
  451.                                         ucKeyLock_04_13=1;
  452.                                         ucKeySec=18;   //被触发18号组合键                           
  453.                                  }
  454.                              
  455.                          }
  456.                   }
  457.                   else
  458.                   {
  459.              uiKeyTimeCnt_04_13=0; //S4和S13组合按键去抖动延时计数器
  460.              ucKeyLock_04_13=0; //S4和S13组合按键触发后自锁的变量标志
  461.                   }

  462.           uiKeyStatus=0xffff;   //及时恢复状态,方便下一次扫描
  463.                   ucKeyStep=1;  //返回到第一个运行步骤重新开始扫描
  464.               break;

  465.   }


  466. }


  467. void key_service() //第三区 按键服务的应用程序
  468. {
  469.   switch(ucKeySec) //按键服务状态切换
  470.   {
  471.     case 1:// 1号键 对应朱兆祺学习板的S1键

  472.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  473.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  474.           break;        
  475.     case 2:// 2号键 对应朱兆祺学习板的S2键

  476.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  477.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  478.           break;     
  479.     case 3:// 3号键 对应朱兆祺学习板的S3键

  480.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  481.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  482.           break;         
  483.     case 4:// 4号键 对应朱兆祺学习板的S4键

  484.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  485.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  486.           break;   
  487.     case 5:// 5号键 对应朱兆祺学习板的S5键

  488.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  489.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  490.           break;   
  491.     case 6:// 6号键 对应朱兆祺学习板的S6键

  492.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  493.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  494.           break;   
  495.     case 7:// 7号键 对应朱兆祺学习板的S7键

  496.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  497.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  498.           break;   
  499.     case 8:// 8号键 对应朱兆祺学习板的S8键

  500.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  501.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  502.           break;   
  503.     case 9:// 9号键 对应朱兆祺学习板的S9键

  504.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  505.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  506.           break;   
  507.     case 10:// 10号键 对应朱兆祺学习板的S10键

  508.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  509.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  510.           break;   
  511.     case 11:// 11号键 对应朱兆祺学习板的S11键

  512.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  513.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  514.           break;   
  515.     case 12:// 12号键 对应朱兆祺学习板的S12键

  516.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  517.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  518.           break;   
  519.     case 13:// 13号键 对应朱兆祺学习板的S13键

  520.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  521.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  522.           break;   
  523.     case 14:// 14号键 对应朱兆祺学习板的S14键

  524.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  525.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  526.           break;   
  527.     case 15:// 15号键 对应朱兆祺学习板的S15键

  528.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  529.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  530.           break;   
  531.     case 16:// 16号键 对应朱兆祺学习板的S16键

  532.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  533.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  534.           break;   

  535.     case 17:// 17号组合键 对应朱兆祺学习板的S1和S16键的组合按键

  536.           led_dr=1; //LED灯亮
  537.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  538.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  539.           break;   

  540.     case 18:// 18号组合键 对应朱兆祺学习板的S4和S13键的组合按键

  541.           led_dr=0; //LED灯灭
  542.           uiVoiceCnt=const_voice_short; //按键声音触发,滴一声就停。
  543.           ucKeySec=0;  //响应按键服务处理程序后,按键编号清零,避免一致触发
  544.           break;   
  545.   }               
  546. }



  547. void T0_time() interrupt 1
  548. {
  549.   TF0=0;  //清除中断标志
  550.   TR0=0; //关中断

  551.   key_scan(); //按键扫描函数

  552.   if(uiVoiceCnt!=0)
  553.   {
  554.      uiVoiceCnt--; //每次进入定时中断都自减1,直到等于零为止。才停止鸣叫
  555.          beep_dr=0;  //蜂鸣器是PNP三极管控制,低电平就开始鸣叫。
  556.   }
  557.   else
  558.   {
  559.      ; //此处多加一个空指令,想维持跟if括号语句的数量对称,都是两条指令。不加也可以。
  560.            beep_dr=1;  //蜂鸣器是PNP三极管控制,高电平就停止鸣叫。
  561.   }


  562.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  563.   TL0=0x2f;
  564.   TR0=1;  //开中断
  565. }


  566. void delay_long(unsigned int uiDelayLong)
  567. {
  568.    unsigned int i;
  569.    unsigned int j;
  570.    for(i=0;i<uiDelayLong;i++)
  571.    {
  572.       for(j=0;j<500;j++)  //内嵌循环的空指令数量
  573.           {
  574.              ; //一个分号相当于执行一条空语句
  575.           }
  576.    }
  577. }


  578. void initial_myself()  //第一区 初始化单片机
  579. {

  580.   led_dr=0; //LED灯灭
  581.   beep_dr=1; //用PNP三极管控制蜂鸣器,输出高电平时不叫。


  582.   TMOD=0x01;  //设置定时器0为工作方式1


  583.   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  584.   TL0=0x2f;

  585. }
  586. void initial_peripheral() //第二区 初始化外围
  587. {
  588.   EA=1;     //开总中断
  589.   ET0=1;    //允许定时中断
  590.   TR0=1;    //启动定时中断

  591. }
复制代码

总结陈词:
    这节讲了如何把矩阵键盘翻译成独立按键的处理方式,然后像独立按键一样实现组合按键的功能,关于矩阵按键的双击,长按和短按,按键连续触发等功能我不再详细介绍,有兴趣的朋友可以参考我前面章节讲的独立按键。在实际的项目中,按键可以控制很多外设。为了以后进一步讲按键控制外设等功能,接下来我会讲哪些新内容呢?欲知详情,请听下回分解-----两片联级74HC595驱动16个LED灯的基本驱动程序。

(未完待续,下节更精彩,不要走开哦)
此帖出自51单片机论坛

回复
您需要登录后才可以回帖 登录 | 注册

猜你喜欢
随便看看
查找数据手册?

EEWorld Datasheet 技术支持

相关文章 更多>>
关闭
站长推荐上一条 1/10 下一条

 
EEWorld订阅号

 
EEWorld服务号

 
汽车开发圈

About Us 关于我们 客户服务 联系方式 器件索引 网站地图 最新更新 手机版

站点相关: 国产芯 安防电子 汽车电子 手机便携 工业控制 家用电子 医疗电子 测试测量 网络通信 物联网

北京市海淀区中关村大街18号B座15层1530室 电话:(010)82350740 邮编:100190

电子工程世界版权所有 京B2-20211791 京ICP备10001474号-1 电信业务审批[2006]字第258号函 京公网安备 11010802033920号 Copyright © 2005-2024 EEWORLD.com.cn, Inc. All rights reserved
快速回复 返回顶部 返回列表