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

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

[复制链接]
364965|721
 楼主| jianhong_wu 发表于 2018-4-12 09:32 | 显示全部楼层
本帖最后由 jianhong_wu 于 2018-4-12 19:36 编辑

第一百一十三节： 动态扫描的数码管显示数字。

【113.1   动态扫描的数码管。】
   
                上图113.1.1  数码管

       上一节，看到打开显示的数码管右起第1个（com4）和第3个(com2)在任意时刻显示的数字是一样的，为什么？因为四个数码管的8个段码a,b,c,d,e,f,g,h所连接的单片机IO口是共用的，如果把四个数码管全部打开（com1,com2,com3,com4全部输出低电平），会发现四个数码管在任意时刻显示的四个数字也是一样的！实际应用中，要四个数码管能各自独立显示不同的数字，就需要用到“分时动态扫描”的方式。所谓分时，就是在任意时刻只能显示其中一个数码管（某个com输出低电平），其它三个数码管关闭（其它三个com输出高电平），每个数码管显示停留的时间固定一致并且非常短暂，四个数码管依次循环的切换显示，只要切换画面的速度足够快，人的视觉就分辨不出来，感觉八个数码管是同时亮的（实际不是同时亮），跟动画片“1秒钟动态切换显示多少幅画面”的原理一样。现在编写一个程序例子，四个数码管要显示四个不同的数字“1234”，程序代码如下：
复制
  1. #include "REG52.H"  
    


  2. 

  3. /* 注释一：
    

  4. *  SCAN_TIME是每个数码管停留显示的短暂时间。这里称为“扫描时间”。这个时间既不能太长也不能
    

  5. *  太短，要调试到恰到好处。太长，则影响其它数码管的显示，会让人觉得画面不连贯不是同时亮；
    

  6. *  太短，又会影响显示的亮度。具体的时间应该根据实际项目不断调试修正而得到最佳显示的数值。
    

  7. */
    


  8. 

  9. #define SCAN_TIME  1    
    


  10. 


  11. 

  12. void T0_time();
    

  13. void SystemInitial(void) ;
    

  14. void Delay(unsigned long u32DelayTime) ;
    

  15. void PeripheralInitial(void) ;
    


  16. 

  17. void DisplayScan(void);    //数码管的动态扫描函数，放在定时中断里。
    


  18. 

  19. sbit P1_0=P1^0;  //右起第1位数码管的公共端com4
    

  20. sbit P1_1=P1^1;  //右起第2位数码管的公共端com3
    

  21. sbit P1_2=P1^2;  //右起第3位数码管的公共端com2
    

  22. sbit P1_3=P1^3;  //右起第4位数码管的公共端com1
    


  23. 

  24. //根据原理图得出的共阴数码管编码转换表，类似于一个字库表
    

  25. code unsigned char Cu8DigTable[]=
    

  26. {
    

  27. 0x3f,  //0       序号0
    

  28. 0x06,  //1       序号1
    

  29. 0x5b,  //2       序号2
    

  30. 0x4f,  //3       序号3
    

  31. 0x66,  //4       序号4
    

  32. 0x6d,  //5       序号5
    

  33. 0x7d,  //6       序号6
    

  34. 0x07,  //7       序号7
    

  35. 0x7f,  //8       序号8
    

  36. 0x6f,  //9       序号9
    

  37. 0x00,  //不显示  序号10
    

  38. };
    


  39. 

  40. volatile unsigned char vGu8ScanTimerFlag=0;  //动态扫描的定时器
    

  41. volatile unsigned int vGu16ScanTimerCnt=0;  
    


  42. 

  43. /* 注释二：
    

  44. *  vGu8Display_Righ_4，vGu8Display_Righ_3，vGu8Display_Righ_2，vGu8Display_Righ_1，这四个
    

  45. *  全局变量用来传递每位数码管需要显示的数字，作为对上面应用层调用的接口变量。
    

  46. */
    


  47. 

  48. volatile unsigned char vGu8Display_Righ_4=1;  //右起第4位数码管显示的变量。这里显示“1”
    

  49. volatile unsigned char vGu8Display_Righ_3=2;  //右起第3位数码管显示的变量。这里显示“2”
    

  50. volatile unsigned char vGu8Display_Righ_2=3;  //右起第2位数码管显示的变量。这里显示“3”
    

  51. volatile unsigned char vGu8Display_Righ_1=4;  //右起第1位数码管显示的变量。这里显示“4”
    


  52. 

  53. void main() 
    

  54. {
    

  55. SystemInitial();            
    

  56. Delay(10000);               
    

  57. PeripheralInitial();      
    

  58.     while(1)  
    

  59. {  
    

  60.     }
    

  61. }
    


  62. 

  63. /* 注释三：
    

  64. *  DisplayScan数码管的动态扫描函数，之所以放在定时中断里，是因为动态扫描数码管对时间均匀度
    

  65. *  要求很高，如果放在main主函数中，期间稍微出现一些延时滞后或者超前执行的情况，都会导致
    

  66. *  数码管出现“闪烁”或者“忽暗忽亮”的显示效果。
    

  67. */
    


  68. 

  69. void DisplayScan(void)   
    

  70. {
    

  71. static unsigned char Su8GetCode;  //从编码转换表中提取出来的编码。
    

  72. static unsigned char Su8ScanStep=1;  //扫描步骤
    


  73. 

  74. if(0==vGu16ScanTimerCnt)  //定时的时间到，切换显示下一个数码管，依次动态快速循环切换显示
    

  75. {
    


  76. 

  77. /* 注释四：
    

  78. *  在即将切换显示到下一个新的数码管之前，应该先关闭显示所有的数码管，避免因关闭不彻底而导致
    

  79. *  数码管某些段位出现“漏光”，也就是数码管因程序处理不善而出现常见的“鬼影”显示情况。
    

  80. */
    


  81. 

  82.     P0=0x00; //输出显示先清零，先关闭显示所有的数码管
    

  83.     //先关闭所有的com口，先关闭显示所有的数码管
    

  84. P1_0=1;  //右起第1位数码管的公共端com4，“总开关”关闭，输出低电平1
    

  85. P1_1=1;  //右起第2位数码管的公共端com3，“总开关”关闭，输出高电平1
    

  86. P1_2=1;  //右起第3位数码管的公共端com2，“总开关”关闭，输出低电平1
    

  87. P1_3=1;  //右起第4位数码管的公共端com1，“总开关”关闭，输出高电平1
    


  88. 

  89.     switch(Su8ScanStep)
    

  90. {
    

  91.        case 1: //显示右起第1个数码管
    

  92. Su8GetCode=Cu8DigTable[vGu8Display_Righ_1]; //从编码转换表中提取出来的编码。
    

  93.     P0=Su8GetCode; //段码端输出需要显示的编码
    

  94. P1_0=0;  //右起第1位数码管的公共端com4，“总开关”打开，输出低电平0
    

  95. P1_1=1;  //右起第2位数码管的公共端com3，“总开关”关闭，输出高电平1
    

  96. P1_2=1;  //右起第3位数码管的公共端com2，“总开关”关闭，输出高电平1
    

  97. P1_3=1;  //右起第4位数码管的公共端com1，“总开关”关闭，输出高电平1            
    

  98. break;
    


  99. 

  100.        case 2: //显示右起第2个数码管
    

  101. Su8GetCode=Cu8DigTable[vGu8Display_Righ_2]; //从编码转换表中提取出来的编码。
    

  102.     P0=Su8GetCode; //段码端输出需要显示的编码
    

  103. P1_0=1;  //右起第1位数码管的公共端com4，“总开关”关闭，输出高电平1
    

  104. P1_1=0;  //右起第2位数码管的公共端com3，“总开关”打开，输出低电平0
    

  105. P1_2=1;  //右起第3位数码管的公共端com2，“总开关”关闭，输出高电平1
    

  106. P1_3=1;  //右起第4位数码管的公共端com1，“总开关”关闭，输出高电平1            
    

  107. break;
    


  108. 

  109.        case 3: //显示右起第3个数码管
    

  110. Su8GetCode=Cu8DigTable[vGu8Display_Righ_3]; //从编码转换表中提取出来的编码。
    

  111.     P0=Su8GetCode; //段码端输出需要显示的编码
    

  112. P1_0=1;  //右起第1位数码管的公共端com4，“总开关”关闭，输出高电平1
    

  113. P1_1=1;  //右起第2位数码管的公共端com3，“总开关”关闭，输出高电平1
    

  114. P1_2=0;  //右起第3位数码管的公共端com2，“总开关”打开，输出低电平0
    

  115. P1_3=1;  //右起第4位数码管的公共端com1，“总开关”关闭，输出高电平1            
    

  116. break;
    


  117. 

  118.        case 4: //显示右起第4个数码管
    

  119. Su8GetCode=Cu8DigTable[vGu8Display_Righ_4]; //从编码转换表中提取出来的编码。
    

  120.     P0=Su8GetCode; //段码端输出需要显示的编码
    

  121. P1_0=1;  //右起第1位数码管的公共端com4，“总开关”关闭，输出高电平1
    

  122. P1_1=1;  //右起第2位数码管的公共端com3，“总开关”关闭，输出高电平1
    

  123. P1_2=1;  //右起第3位数码管的公共端com2，“总开关”关闭，输出高电平1
    

  124. P1_3=0;  //右起第4位数码管的公共端com1，“总开关”打开，输出低电平0            
    

  125. break;
    


  126. 

  127. }
    


  128. 

  129. Su8ScanStep++;
    

  130. if(Su8ScanStep>4) //如果扫描步骤大于4，继续从第1步开始扫描
    

  131. {
    

  132. Su8ScanStep=1;
    


  133. 

  134. }
    


  135. 

  136. vGu8ScanTimerFlag=0; 
    

  137. vGu16ScanTimerCnt=SCAN_TIME;  
    

  138. vGu8ScanTimerFlag=1;  //启动新一轮的定时器
    

  139. }
    

  140. }
    


  141. 

  142. void T0_time() interrupt 1     
    

  143. {
    

  144. DisplayScan(); //数码管的动态扫描函数
    


  145. 

  146. if(1==vGu8ScanTimerFlag&&vGu16ScanTimerCnt>0)  //数码管显示切换时间的定时器
    

  147. {
    

  148. vGu16ScanTimerCnt--;
    

  149. }
    


  150. 

  151.     
    

  152. TH0=0xfc;   
    

  153. TL0=0x66;   
    

  154. }
    


  155. 


  156. 

  157. void SystemInitial(void) 
    

  158. {
    

  159. //初始化上电瞬间数码管的状态，关闭显示所有的数码管
    

  160. P0=0x00;
    

  161. P1_0=1;  //右起第1位数码管的公共端com4，“总开关”关闭，输出低电平1
    

  162. P1_1=1;  //右起第2位数码管的公共端com3，“总开关”关闭，输出高电平1
    

  163. P1_2=1;  //右起第3位数码管的公共端com2，“总开关”关闭，输出低电平1
    

  164. P1_3=1;  //右起第4位数码管的公共端com1，“总开关”关闭，输出高电平1
    

  165.     
    

  166. TMOD=0x01;  
    

  167. TH0=0xfc;   
    

  168. TL0=0x66;   
    

  169. EA=1;       
    

  170. ET0=1;      
    

  171. TR0=1;      
    

  172. }
    


  173. 

  174. void Delay(unsigned long u32DelayTime) 
    

  175. {
    

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

  177. }
    


  178. 

  179. void PeripheralInitial(void) 
    

  180. {
    


  181. 

  182. }
    


  183. 


  184.




本帖子中包含更多资源

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

×
回复

收藏269 举报

y15067805290 发表于 2018-4-12 16:29 | 显示全部楼层

期待楼主给我们带来更多的干货哦~~
回复

收藏269 举报

wangwenwuaisiyu 发表于 2018-4-13 09:22 | 显示全部楼层
支持一下楼主
回复

收藏269 举报

wangwenwuaisiyu 发表于 2018-4-13 16:20 | 显示全部楼层
讲的太好了，看了一天都不觉的的累，越看越来劲了，
回复

收藏269 举报

michael1982 发表于 2018-4-13 18:33 | 显示全部楼层
膜拜大牛
回复

收藏269 举报

 楼主| jianhong_wu 发表于 2018-4-16 12:53 | 显示全部楼层
第一百一十四节： 动态扫描的数码管显示小数点。

【114.1   动态扫描的数码管显示小数点。】
   
                上图114.1.1  数码管

       如上图，小数点的段码是h，对应单片机的P0.7口。数码管编码转换表（类似字库）的11个以字节为单位的数据，把它们从十六进制转换成二进制后，可以发现第7位（对应P0.7口）都是0。因此，从转换表里取数据后，得到的数据默认是让数码管的小数点不显示的。如果想显示这个小数点，就需要用到“或（|）”语句操作。比如，本节程序需要显示“1.234”这个带小数点的数值，代码如下：


复制

  1. 

  2. #include "REG52.H"  
    


  3. 

  4. #define SCAN_TIME  1    
    


  5. 

  6. void T0_time();
    

  7. void SystemInitial(void) ;
    

  8. void Delay(unsigned long u32DelayTime) ;
    

  9. void PeripheralInitial(void) ;
    


  10. 

  11. void DisplayScan(void);    
    


  12. 

  13. sbit P1_0=P1^0;  
    

  14. sbit P1_1=P1^1;  
    

  15. sbit P1_2=P1^2;  
    

  16. sbit P1_3=P1^3; 
    


  17. 

  18. //转换表，里面的11个数据，转换成二进制后，第7位数据都是0默认不显示小数点
    

  19. code unsigned char Cu8DigTable[]=
    

  20. {
    

  21. 0x3f,  //0       序号0
    

  22. 0x06,  //1       序号1
    

  23. 0x5b,  //2       序号2
    

  24. 0x4f,  //3       序号3
    

  25. 0x66,  //4       序号4
    

  26. 0x6d,  //5       序号5
    

  27. 0x7d,  //6       序号6
    

  28. 0x07,  //7       序号7
    

  29. 0x7f,  //8       序号8
    

  30. 0x6f,  //9       序号9
    

  31. 0x00,  //不显示  序号10
    

  32. };
    


  33. 

  34. volatile unsigned char vGu8ScanTimerFlag=0;  
    

  35. volatile unsigned int vGu16ScanTimerCnt=0;  
    


  36. 


  37. 

  38. volatile unsigned char vGu8Display_Righ_4=1;  //右起第4位数码管显示的变量。这里显示“1”
    

  39. volatile unsigned char vGu8Display_Righ_3=2;  //右起第3位数码管显示的变量。这里显示“2”
    

  40. volatile unsigned char vGu8Display_Righ_2=3;  //右起第2位数码管显示的变量。这里显示“3”
    

  41. volatile unsigned char vGu8Display_Righ_1=4;  //右起第1位数码管显示的变量。这里显示“4”
    


  42. 

  43. /* 注释一：
    

  44. *  vGu8Display_Righ_Dot_4，vGu8Display_Righ_Dot_3，vGu8Display_Righ_Dot_2，
    

  45. *  vGu8Display_Righ_Dot_1，这四个全局变量用来传递每位数码管是否需要显示它的小数点，如果是1
    

  46. *  代表需要显示其小数点，如果是0则不显示小数点。这四个变量作为对上面应用层调用的接口变量。
    

  47. */
    


  48. 

  49. volatile unsigned char vGu8Display_Righ_Dot_4=1;  //右起第4位数码管的小数点。1代表打开显示。
    

  50. volatile unsigned char vGu8Display_Righ_Dot_3=0;  //右起第3位数码管的小数点。0代表关闭显示。
    

  51. volatile unsigned char vGu8Display_Righ_Dot_2=0;  //右起第2位数码管的小数点。0代表关闭显示。
    

  52. volatile unsigned char vGu8Display_Righ_Dot_1=0;  //右起第1位数码管的小数点。0代表关闭显示。
    


  53. 

  54. void main() 
    

  55. {
    

  56. SystemInitial();            
    

  57. Delay(10000);               
    

  58. PeripheralInitial();      
    

  59.     while(1)  
    

  60. {  
    

  61.     }
    

  62. }
    


  63. 


  64. 

  65. void DisplayScan(void)   
    

  66. {
    

  67. static unsigned char Su8GetCode;  
    

  68. static unsigned char Su8ScanStep=1;  
    


  69. 

  70. if(0==vGu16ScanTimerCnt)  
    

  71. {
    


  72. 


  73. 

  74.     P0=0x00; 
    

  75. P1_0=1;  
    

  76. P1_1=1;  
    

  77. P1_2=1;  
    

  78. P1_3=1;  
    


  79. 

  80.     switch(Su8ScanStep)
    

  81. {
    

  82.        case 1: 
    

  83. Su8GetCode=Cu8DigTable[vGu8Display_Righ_1]; 
    


  84. 

  85. /* 注释二：
    

  86. *  这里是本节的关键。通过判断全局的接口变量的数值，来决定是否打开显示小数点。
    

  87. *  从转换表取出字模数据后再跟0x80进行“或”运算即可把第7位数据改为1。
    

  88. */
    


  89. 

  90. if(1==vGu8Display_Righ_Dot_1) //如果打开了需要显示第1个数码管的小数点
    

  91. {
    

  92. Su8GetCode=Su8GetCode|0x80;  //把第7位数据改为1，显示小数点
    

  93. }
    

  94.     P0=Su8GetCode; 
    

  95. P1_0=0; 
    

  96. P1_1=1;  
    

  97. P1_2=1;  
    

  98. P1_3=1;            
    

  99. break;
    


  100. 

  101.        case 2: 
    

  102. Su8GetCode=Cu8DigTable[vGu8Display_Righ_2]; 
    

  103. if(1==vGu8Display_Righ_Dot_2) //如果打开了需要显示第2个数码管的小数点
    

  104. {
    

  105. Su8GetCode=Su8GetCode|0x80;  //把第7位数据改为1，显示小数点
    

  106. }
    

  107.     P0=Su8GetCode;
    

  108. P1_0=1;  
    

  109. P1_1=0; 
    

  110. P1_2=1; 
    

  111. P1_3=1;          
    

  112. break;
    


  113. 

  114.        case 3: 
    

  115. Su8GetCode=Cu8DigTable[vGu8Display_Righ_3];
    

  116. if(1==vGu8Display_Righ_Dot_3) //如果打开了需要显示第3个数码管的小数点
    

  117. {
    

  118. Su8GetCode=Su8GetCode|0x80;  //把第7位数据改为1，显示小数点
    

  119. }
    

  120.     P0=Su8GetCode;
    

  121. P1_0=1;  
    

  122. P1_1=1;  
    

  123. P1_2=0;  
    

  124. P1_3=1;         
    

  125. break;
    


  126. 

  127.        case 4: 
    

  128. Su8GetCode=Cu8DigTable[vGu8Display_Righ_4]; 
    

  129. if(1==vGu8Display_Righ_Dot_4) //如果打开了需要显示第4个数码管的小数点
    

  130. {
    

  131. Su8GetCode=Su8GetCode|0x80;  //把第7位数据改为1，显示小数点
    

  132. }
    

  133.     P0=Su8GetCode; 
    

  134. P1_0=1;  
    

  135. P1_1=1;  
    

  136. P1_2=1;  
    

  137. P1_3=0;           
    

  138. break;
    


  139. 

  140. }
    


  141. 

  142. Su8ScanStep++;
    

  143. if(Su8ScanStep>4) 
    

  144. {
    

  145. Su8ScanStep=1;
    

  146. }
    


  147. 

  148. vGu8ScanTimerFlag=0; 
    

  149. vGu16ScanTimerCnt=SCAN_TIME;  
    

  150. vGu8ScanTimerFlag=1;  
    

  151. }
    

  152. }
    


  153. 

  154. void T0_time() interrupt 1     
    

  155. {
    

  156. DisplayScan(); 
    


  157. 

  158. if(1==vGu8ScanTimerFlag&&vGu16ScanTimerCnt>0)  
    

  159. {
    

  160. vGu16ScanTimerCnt--;
    

  161. }
    


  162. 


  163. 

  164. TH0=0xfc;   
    

  165. TL0=0x66;   
    

  166. }
    


  167. 


  168. 

  169. void SystemInitial(void) 
    

  170. {
    

  171. P0=0x00;
    

  172. P1_0=1;  
    

  173. P1_1=1;  
    

  174. P1_2=1;  
    

  175. P1_3=1;  
    


  176. 

  177. TMOD=0x01;  
    

  178. TH0=0xfc;   
    

  179. TL0=0x66;   
    

  180. EA=1;       
    

  181. ET0=1;      
    

  182. TR0=1;      
    

  183. }
    


  184. 

  185. void Delay(unsigned long u32DelayTime) 
    

  186. {
    

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

  188. }
    


  189. 

  190. void PeripheralInitial(void) 
    

  191. {
    


  192. 

  193. }


本帖子中包含更多资源

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

×
回复

收藏269 举报

 楼主| jianhong_wu 发表于 2018-4-22 12:07 | 显示全部楼层
第一百一十五节： 按键控制数码管的秒表。

【115.1   按键控制数码管的秒表。】
   
                上图115.1.1  数码管




                上图115.1.2  独立按键

       本节通过一个秒表的小项目，让大家学会以下4个知识点：
      （1）上层的界面显示框架几乎都要用到更新变量，更新变量包括整屏更新和局部更新，本节只用到整屏更新。更新变量是用全局变量在函数之间传递信息。作用是，当有某个需要显示的数据发生改变的时候，就要给更新变量置1，让显示函数重新更新一次显示，确保最新的数据能及时显示出来，平时没有数据更新改变的时候不用频繁更新显示避免占用CPU过多的时间。
      （2）凡是需要显示数字的地方，都必须涉及如何把一个数据按“个十百千万...”的位逐个提取出来的算法。这个算法比较简单，主要用“求余”和“求商”这两个运算语句就可以随心所欲的把数据位提取出来。除此之外，还要学会如何用if语句判断数据的范围，来把高位尚未用到的某个数码管屏蔽，让该位数码管只显示一个“不显示”的数据（避免直接显示一个0）。
      （3）我常把单片机程序简化成4个代表：按键（人机输入），数码管（人机界面），跑马灯（应用程序），串口（通信）。本节的“应用程序”不是跑马灯，而是秒表。不管是跑马灯，还是秒表，都要用到一个总启动Gu8RunStart和一个总运行步骤Gu8RunStep。建议大家，总启动Gu8RunStart和总运行步骤Gu8RunStep应该成双成对的出现（这样关断响应更及时，并且结构更紧凑，漏洞更少），比如，凡是总启动Gu8RunStart发生改变的时候，总运行步骤Gu8RunStep都复位归零一下。
      （4）一个硬件的定时器中断，可以衍生出N个软件定时器，之前跟大家介绍的是“递减式”的软件定时器，而且实际应用中，“递减式”的软件定时器也是用得最多。本节因为项目的需要，需要用到的是“累加式”的软件定时器。不管是哪种软件定时器，大家都要注意定时器变量在定义时所用到的数据类型，这个数据类型决定了定时时间的长度，比如在51单片机中，unsigned int的范围是0到65535，最大一次性定时65.535秒。而unsigned long的范围是0到4294967295，最大一次性定时4294967.295秒。本节秒表的时间超过65.535秒，因此需要用到unsigned long类型的定时器变量。
本节秒表程序的功能：K1按键是复位按键，每按一次，秒表都停止并且重新归零。K2按键是启动和暂停按键，当秒表处于复位后停止的状态时按一次则开始启动，当秒表处于正在工作的状态时按一次则处于暂停状态，当秒表处于暂停的状态时按一次则继续处于工作的状态。本节4位数码管，显示的时间是带2位小数点的，能显示的时间范围是：0.00秒到99.99秒。代码如下：

复制
  1. #include "REG52.H"  
    


  2. 

  3. #define KEY_FILTER_TIME  25 
    


  4. 

  5. #define SCAN_TIME  1    
    


  6. 

  7. void T0_time();
    

  8. void SystemInitial(void) ;
    

  9. void Delay(unsigned long u32DelayTime) ;
    

  10. void PeripheralInitial(void) ;
    


  11. 

  12. void KeyScan(void);  
    

  13. void KeyTask(void);  
    


  14. 

  15. void DisplayScan(void);  //底层显示的驱动函数  
    

  16. void DisplayTask(void);  //上层显示的任务函数
    


  17. 

  18. void RunTask(void);  //秒表的应用程序
    


  19. 

  20. sbit KEY_INPUT1=P2^2;  
    

  21. sbit KEY_INPUT2=P2^1;  
    


  22. 

  23. sbit P1_0=P1^0;  
    

  24. sbit P1_1=P1^1;  
    

  25. sbit P1_2=P1^2;  
    

  26. sbit P1_3=P1^3; 
    


  27. 

  28. //数码管转换表
    

  29. code unsigned char Cu8DigTable[]=
    

  30. {
    

  31. 0x3f,  //0       序号0
    

  32. 0x06,  //1       序号1
    

  33. 0x5b,  //2       序号2
    

  34. 0x4f,  //3       序号3
    

  35. 0x66,  //4       序号4
    

  36. 0x6d,  //5       序号5
    

  37. 0x7d,  //6       序号6
    

  38. 0x07,  //7       序号7
    

  39. 0x7f,  //8       序号8
    

  40. 0x6f,  //9       序号9
    

  41. 0x00,  //不显示  序号10
    

  42. };
    


  43. 

  44. //数码管底层驱动扫描的软件定时器
    

  45. volatile unsigned char vGu8ScanTimerFlag=0;  
    

  46. volatile unsigned int vGu16ScanTimerCnt=0;  
    


  47. 

  48. //秒表的软件定时器，注意，这里是unsigned long类型，范围是0到4294967295毫秒
    

  49. volatile unsigned char vGu8StopWatchTimerFlag=0;  
    

  50. volatile unsigned long vGu32StopWatchTimerCnt=0;  
    


  51. 

  52. //数码管上层每10ms就定时刷新一次显示的软件定时器。用于及时更新显示秒表当前的实时数值
    

  53. volatile unsigned char vGu8UpdateTimerFlag=0;  
    

  54. volatile unsigned int vGu16UpdateTimerCnt=0;  
    


  55. 


  56. 

  57. unsigned char Gu8RunStart=0;  //应用程序的总启动
    

  58. unsigned char Gu8RunStep=0;  //应用程序的总运行步骤。建议跟vGu8RunStart成双成对出现
    

  59. unsigned char Gu8RunStatus=0; //当前秒表的状态。0代表停止，1代表正在工作中，2代表暂停
    


  60. 

  61. unsigned char Gu8WdUpdate=1;  //开机默认整屏更新一次显示。此变量在显示框架中是非常重要的变量
    


  62. 

  63. volatile unsigned char vGu8Display_Righ_4=10;  //开机默认最高位数码管显示一个“不显示”数据
    

  64. volatile unsigned char vGu8Display_Righ_3=0;  
    

  65. volatile unsigned char vGu8Display_Righ_2=0;  
    

  66. volatile unsigned char vGu8Display_Righ_1=0;  
    


  67. 

  68. volatile unsigned char vGu8Display_Righ_Dot_4=0;  
    

  69. volatile unsigned char vGu8Display_Righ_Dot_3=1;    //开机默认保留显示2个小数点 
    

  70. volatile unsigned char vGu8Display_Righ_Dot_2=0;  
    

  71. volatile unsigned char vGu8Display_Righ_Dot_1=0;  
    


  72. 

  73. volatile unsigned char vGu8KeySec=0;  
    


  74. 

  75. void main() 
    

  76. {
    

  77. SystemInitial();            
    

  78. Delay(10000);               
    

  79. PeripheralInitial();      
    

  80.     while(1)  
    

  81. {  
    

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

  83. DisplayTask();  //数码管显示的上层任务函数
    

  84. RunTask();      //秒表的应用程序
    

  85.     }
    

  86. }
    


  87. 

  88. void KeyTask(void)    //按键的任务函数
    

  89. {
    

  90. if(0==vGu8KeySec)
    

  91. {
    

  92. return; 
    

  93. }
    


  94. 

  95. switch(vGu8KeySec) 
    

  96. {
    

  97.    case 1:     //复位按键
    


  98. 

  99. Gu8RunStatus=0; //秒表返回停止的状态
    


  100. 

  101. Gu8RunStart=0;  //秒表停止
    

  102.             Gu8RunStep=0;  //总运行步骤归零。建议跟vGu8RunStart成双成对出现
    


  103. 

  104. vGu8StopWatchTimerFlag=0;  
    

  105. vGu32StopWatchTimerCnt=0;   //秒表的软件定时器清零
    


  106. 

  107.             Gu8WdUpdate=1;  //整屏更新一次显示
    


  108. 

  109. vGu8KeySec=0;  
    

  110. break;
    


  111. 

  112.    case 2:     //启动与暂停的按键
    

  113.         if(0==Gu8RunStatus) //在停止状态下
    

  114.         {
    

  115.             Gu8RunStatus=1;  //秒表处于工作状态
    


  116. 

  117. vGu8StopWatchTimerFlag=0; 
    

  118. vGu32StopWatchTimerCnt=0;  
    

  119. vGu8StopWatchTimerFlag=1;  //启动秒表的软件定时器
    


  120. 


  121. 

  122. Gu8RunStart=1;   //秒表总开关启动
    

  123.                 Gu8RunStep=0;    //总运行步骤归零。建议跟vGu8RunStart成双成对出现
    

  124. }
    

  125.         else if(1==Gu8RunStatus) //在工作状态下
    

  126.         {
    

  127.             Gu8RunStatus=2;  //秒表处于暂停状态
    

  128. }
    

  129.         else  //在暂停状态下
    

  130.         {
    

  131.             Gu8RunStatus=1;  //秒表处于工作状态
    

  132. }
    


  133. 

  134.         Gu8WdUpdate=1;  //整屏更新一次显示，确保在暂停的时候能显示到最新的数据
    


  135. 

  136. vGu8KeySec=0; 
    

  137. break;
    


  138. 

  139. }
    

  140. }
    


  141. 

  142. void DisplayTask(void) //数码管显示的上层任务函数
    

  143. {
    

  144. //需要借用的中间变量，用来拆分数据位
    

  145. static unsigned char Su8Temp_4,Su8Temp_3,Su8Temp_2,Su8Temp_1; //需要借用的中间变量
    


  146. 

  147. /* 注释一：
    

  148. *  此处为什么要多加4个中间过渡变量Su8Temp_X？是因为vGu32StopWatchTimerCnt分解数据的时候
    

  149. *  需要进行除法和求余数的运算，就会用到好多条指令，就会耗掉一点时间，类似延时了一会。我们
    

  150. *  的定时器每隔一段时间都会产生中断，然后在中断里驱动数码管显示，当vGu32StopWatchTimerCnt
    

  151. *  还没完全分解出4位有效数据时，这个时候来的定时中断，就有可能导致显示的数据瞬间产生不完整,
    

  152. *  影响显示效果。因此，为了把需要显示的数据过渡最快，所以采取了先分解，再过渡显示的方法。
    

  153. */
    


  154. 

  155. if(1==Gu8WdUpdate) //如果需要整屏更新
    

  156. {
    

  157. Gu8WdUpdate=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
    


  158. 

  159.           //先分解数据
    


  160. 

  161.           //Su8Temp_4提取“十秒”位。
    

  162. Su8Temp_4=vGu32StopWatchTimerCnt/10000; //实际精度是0.0001秒,但显示精度是0.01秒
    

  163. Su8Temp_4=Su8Temp_4%10;
    


  164. 

  165.          //Su8Temp_3提取“个秒”位。
    

  166. Su8Temp_3=vGu32StopWatchTimerCnt/1000; //实际精度是0.0001秒,但显示精度是0.01秒
    

  167. Su8Temp_3=Su8Temp_3%10;
    


  168. 

  169.          //Su8Temp_2提取“百毫秒”位。
    

  170. Su8Temp_2=vGu32StopWatchTimerCnt/100; //实际精度是0.0001秒,但显示精度是0.01秒
    

  171. Su8Temp_2=Su8Temp_2%10;
    


  172. 

  173.           //Su8Temp_1提取“十毫秒”位。
    

  174. Su8Temp_1=vGu32StopWatchTimerCnt/10; //实际精度是0.0001秒,但显示精度是0.01秒
    

  175. Su8Temp_1=Su8Temp_1%10;
    


  176. 

  177.           //判断数据范围，来决定最高位数码管是否需要显示。
    

  178.           if(vGu32StopWatchTimerCnt<10000) //10.000秒。实际4位数码管最大只能显示99.99秒
    

  179.           {
    

  180.              Su8Temp_4=10;  //在数码管转换表里，10代表一个“不显示”的数据
    

  181. }
    


  182. 

  183. //上面先分解数据之后，再过渡需要显示的数据到底层驱动变量里，让过渡的时间越短越好
    

  184. vGu8Display_Righ_4=Su8Temp_4;  //过渡需要显示的数据到底层驱动变量
    

  185. vGu8Display_Righ_3=Su8Temp_3;  
    

  186. vGu8Display_Righ_2=Su8Temp_2;  
    

  187. vGu8Display_Righ_1=Su8Temp_1;  
    


  188. 

  189. vGu8Display_Righ_Dot_4=0;  
    

  190. vGu8Display_Righ_Dot_3=1;   //保留显示2位小数点
    

  191. vGu8Display_Righ_Dot_2=0;  
    

  192. vGu8Display_Righ_Dot_1=0;  
    


  193. 

  194. }
    

  195. }
    


  196. 

  197. void RunTask(void)  //秒表的应用程序
    

  198. { 
    

  199. if(0==Gu8RunStart) 
    

  200. {
    

  201.    return;  // 如果秒表处于停止状态，则直接退出当前函数，不执行该函数以下的其它代码
    

  202. }
    


  203. 

  204. switch(Gu8RunStep)
    

  205. {
    

  206.     case 0:  //在这个步骤里，主要用来初始化一些参数
    


  207. 

  208. vGu8UpdateTimerFlag=0;
    

  209. vGu16UpdateTimerCnt=10;  //每10ms更新显示一次当前秒表的时间
    

  210. vGu8UpdateTimerFlag=1;
    


  211. 

  212. Gu8RunStep=1; //跳转到每10ms更新显示一次的步骤里
    

  213. break;
    


  214. 

  215.     case 1:  //每10ms更新一次显示，确保实时显示秒表当前的时间
    

  216.        if(0==vGu16UpdateTimerCnt) //每10ms更新显示一次当前秒表的时间
    

  217.        {
    

  218.     vGu8UpdateTimerFlag=0;
    

  219. vGu16UpdateTimerCnt=10;  //重置定时器，为下一个10ms更新做准备
    

  220. vGu8UpdateTimerFlag=1;
    


  221. 

  222.             Gu8WdUpdate=1;  //整屏更新一次显示当前秒表的时间
    

  223. }
    

  224. break;
    


  225. 

  226. }
    


  227. 

  228. }
    


  229. 


  230. 

  231. void KeyScan(void)  //按键底层的驱动扫描函数，放在定时中断函数里
    

  232. {
    

  233.    static unsigned char Su8KeyLock1; 
    

  234.    static unsigned int  Su16KeyCnt1; 
    

  235.    static unsigned char Su8KeyLock2; 
    

  236.    static unsigned int  Su16KeyCnt2; 
    


  237. 

  238.    if(0!=KEY_INPUT1)
    

  239.    {
    

  240.       Su8KeyLock1=0; 
    

  241.       Su16KeyCnt1=0;   
    

  242.    }
    

  243.    else if(0==Su8KeyLock1)
    

  244.    {
    

  245.       Su16KeyCnt1++;
    

  246.       if(Su16KeyCnt1>=KEY_FILTER_TIME) 
    

  247.       {
    

  248.          Su8KeyLock1=1;  
    

  249.          vGu8KeySec=1;    
    

  250.       }
    

  251.    }
    


  252. 

  253.    if(0!=KEY_INPUT2)
    

  254.    {
    

  255.       Su8KeyLock2=0; 
    

  256.       Su16KeyCnt2=0;       
    

  257.    }
    

  258.    else if(0==Su8KeyLock2)
    

  259.    {
    

  260.       Su16KeyCnt2++; 
    

  261.       if(Su16KeyCnt2>=KEY_FILTER_TIME) 
    

  262.       {
    

  263.          Su8KeyLock2=1;  
    

  264.          vGu8KeySec=2;    
    

  265.       }
    

  266.    }
    

  267. }
    


  268. 

  269. void DisplayScan(void)    //数码管底层的驱动扫描函数，放在定时中断函数里
    

  270. {
    

  271. static unsigned char Su8GetCode;  
    

  272. static unsigned char Su8ScanStep=1;  
    


  273. 

  274. if(0==vGu16ScanTimerCnt)  
    

  275. {
    


  276. 


  277. 

  278.     P0=0x00; 
    

  279. P1_0=1;  
    

  280. P1_1=1;  
    

  281. P1_2=1;  
    

  282. P1_3=1;  
    


  283. 

  284.     switch(Su8ScanStep)
    

  285. {
    

  286.        case 1: 
    

  287. Su8GetCode=Cu8DigTable[vGu8Display_Righ_1]; 
    


  288. 

  289. if(1==vGu8Display_Righ_Dot_1) 
    

  290. {
    

  291. Su8GetCode=Su8GetCode|0x80;  
    

  292. }
    

  293.     P0=Su8GetCode; 
    

  294. P1_0=0; 
    

  295. P1_1=1;  
    

  296. P1_2=1;  
    

  297. P1_3=1;            
    

  298. break;
    


  299. 

  300.        case 2: 
    

  301. Su8GetCode=Cu8DigTable[vGu8Display_Righ_2]; 
    

  302. if(1==vGu8Display_Righ_Dot_2) 
    

  303. {
    

  304. Su8GetCode=Su8GetCode|0x80;  
    

  305. }
    

  306.     P0=Su8GetCode;
    

  307. P1_0=1;  
    

  308. P1_1=0; 
    

  309. P1_2=1; 
    

  310. P1_3=1;          
    

  311. break;
    


  312. 

  313.        case 3: 
    

  314. Su8GetCode=Cu8DigTable[vGu8Display_Righ_3];
    

  315. if(1==vGu8Display_Righ_Dot_3) 
    

  316. {
    

  317. Su8GetCode=Su8GetCode|0x80;  
    

  318. }
    

  319.     P0=Su8GetCode;
    

  320. P1_0=1;  
    

  321. P1_1=1;  
    

  322. P1_2=0;  
    

  323. P1_3=1;         
    

  324. break;
    


  325. 

  326.        case 4: 
    

  327. Su8GetCode=Cu8DigTable[vGu8Display_Righ_4]; 
    

  328. if(1==vGu8Display_Righ_Dot_4) 
    

  329. {
    

  330. Su8GetCode=Su8GetCode|0x80;  
    

  331. }
    

  332.     P0=Su8GetCode; 
    

  333. P1_0=1;  
    

  334. P1_1=1;  
    

  335. P1_2=1;  
    

  336. P1_3=0;           
    

  337. break;
    


  338. 

  339. }
    


  340. 

  341. Su8ScanStep++;
    

  342. if(Su8ScanStep>4) 
    

  343. {
    

  344. Su8ScanStep=1;
    

  345. }
    


  346. 

  347. vGu8ScanTimerFlag=0; 
    

  348. vGu16ScanTimerCnt=SCAN_TIME;  
    

  349. vGu8ScanTimerFlag=1;  
    

  350. }
    

  351. }
    


  352. 

  353. void T0_time() interrupt 1     
    

  354. {
    

  355. KeyScan();      //按键底层的驱动扫描函数
    

  356. DisplayScan();  //数码管底层的驱动扫描函数
    


  357. 

  358. if(1==vGu8ScanTimerFlag&&vGu16ScanTimerCnt>0)  
    

  359. {
    

  360. vGu16ScanTimerCnt--;  //递减式的软件定时器
    

  361. }
    


  362. 

  363. //每10ms就定时更新一次显示的软件定时器
    

  364. if(1==vGu8UpdateTimerFlag&&vGu16UpdateTimerCnt>0)  
    

  365. {
    

  366. vGu16UpdateTimerCnt--;  //递减式的软件定时器
    

  367. }
    


  368. 

  369. //秒表实际走的时间的软件定时器，注意，这里是“累加式”的软件定时器
    

  370. if(1==vGu8StopWatchTimerFlag&&1==Gu8RunStatus) //秒表处于工作的状态
    

  371. {
    

  372. vGu32StopWatchTimerCnt++;  //累加式的软件定时器
    

  373. }
    


  374. 


  375. 

  376. TH0=0xfc;   
    

  377. TL0=0x66;   
    

  378. }
    


  379. 


  380. 

  381. void SystemInitial(void) 
    

  382. {
    

  383. P0=0x00;
    

  384. P1_0=1;  
    

  385. P1_1=1;  
    

  386. P1_2=1;  
    

  387. P1_3=1;  
    


  388. 

  389. TMOD=0x01;  
    

  390. TH0=0xfc;   
    

  391. TL0=0x66;   
    

  392. EA=1;       
    

  393. ET0=1;      
    

  394. TR0=1;      
    

  395. }
    


  396. 

  397. void Delay(unsigned long u32DelayTime) 
    

  398. {
    

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

  400. }
    


  401. 

  402. void PeripheralInitial(void) 
    

  403. {
    


  404. 

  405. }


本帖子中包含更多资源

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

×
回复

收藏269 举报

arima 发表于 2018-4-23 12:36 | 显示全部楼层
加油!!!
回复

收藏269 举报

伯乐121 发表于 2018-4-24 09:43 | 显示全部楼层
arima 发表于 2018-4-23 12:36
加油!!!

本公司诚聘电子工程师：
一.岗位要求
1. 本科以上学历，机电一体化、电子、电子信息等电子类相关专业;
2.2年以上电子设计相关经验
3. 熟悉基本的数字电路和模拟电路,能分析常见电路的工作原理
4. 熟练掌握单片机C语言编程，有良好的编程风格;至少熟练使用一种单片机(STM8/STM32等)进行产品开发
5. 良好的逻辑思维能力，能比较好的对产品进行整体把控；
6. 能积极主动解决产品设计中遇到的各种问题
7. 具有良好的团队合作精神，服从工作安排
8. 参加电子设计大赛并获奖者，或参加过学校电子协会的优先；
9、要求英语4级以上，能较流畅的阅读元器件英文版datasheet
10、有较好的学习能力和一定的抗压能力，能够独立解决技术问题，根据项目需要主动学习和掌握新的技术。

二.岗位职责
从事智能门锁（指纹密码锁、酒店锁、柜锁、联网锁等）的软硬件设计
具体职责包括：1. 客户需求整理（客户提供功能定义、电路板尺寸图等）
2. 原理图设计和审核,包括指纹、触摸密码、13.56MHz卡片读写、125KHz卡片读写、语音、遥控、OLED液晶显示等，这些都已经实现了模块化，只需根据客户要求做少量调整；
3.重点是 MCU单片机程序编写，主要使用STM8/STM32
4. 生产文档制作，包括物料清单、生产指导书、生产测试文档等，都是基于公司的模板来做。
5. 编写产品使用说明书
6.各种新技术/新方案的研发和集成




三.补充职位亮点
1.根据个人能力月薪8-12K，按国家法定节假日放假，过试用期购买保险。
2一般有月平均实发工资的2倍左右作为年终奖              
3.每天有工作下午茶：水果、点心、咖啡等
4.每几月不定期的举行集体活动：徒步、登山、看电影、烧烤等。
5.一年两次旅游
工作地点：东莞市石碣镇
联系人：李'S       QQ:244714897

回复

收藏269 举报

chentiaotiao 发表于 2018-4-25 14:36 | 显示全部楼层
jianhong_wu 发表于 2017-9-4 19:36
第八十五节： 定时中断的寄存器配置。

【85.1   寄存器配置的本质。】

吴老师，如果我把案例里的if判断语句>=改成<=的话，我发现LED灯还是会闪烁，而且频率更快了，这是怎么回事呢？
回复

收藏269 举报

yhchen2001 发表于 2018-4-26 14:00 | 显示全部楼层
为无私的老师点赞!
回复

收藏269 举报

xiaofengfeng 发表于 2018-4-28 22:41 | 显示全部楼层
希望中国工程师 联合
回复

收藏269 举报

 楼主| jianhong_wu 发表于 2018-4-30 11:50 | 显示全部楼层
第一百一十六节： 按键控制数码管的倒计时。

【116.1   按键控制数码管的倒计时。】
  
                上图116.1.1  数码管




                上图116.1.2  独立按键

         
                上图116.1.3  有源蜂鸣器

       上一节讲“累加式”的秒表，这一节讲“递减式”的倒计时。通过此小项目，加深理解在显示框架中常用的更新变量（整屏更新和局部更新），以及应用程序与按键是如何关联的框架。同时，在拆分“个十百千万...”的时候，有一处地方必须注意，“先整除后求余”必须用一行代码一气呵成，不能拆分成两行代码“先整除；后求余”，否则会有隐患会有bug。除非，把四个临时变都改成unsigned long类型。上一节在此处残留了一个bug我发帖后还来不及修改过来，敬请大家注意。比如：

        以下这样是对的：
复制
  1. static unsigned char Su8Temp_1;
    

  2. Su8Temp_1=vGu32CountdownTimerCnt/10%10; //一气呵成，没毛病。


        以下这样是有隐患有bug的（除非把Su8Temp_1改成unsigned long类型）：
复制
  1. static unsigned char Su8Temp_1;
    

  2. Su8Temp_1=vGu32CountdownTimerCnt/10; 
    

  3. Su8Temp_1=Su8Temp_1%10; //拆分成两行代码后，有隐患有bug。数据溢出的原因引起。


        本节倒计时程序的功能：K1按键是复位按键，每按一次，倒计时停止并且重新恢复初始值10.00秒。K2按键是启动按键，当秒表处于复位后停止的状态时按一次则开始启动倒计时，当倒计时变为0.00秒的时候，蜂鸣器发出一次“滴”的提示声。此时，如果想启动新一轮的倒计时，只需按一次K1复位键，然后再按K2启动按键，就可以启动新一轮10.00秒的倒计时。代码如下：

复制
  1. #include "REG52.H"  
    


  2. 

  3. #define KEY_FILTER_TIME  25 
    


  4. 

  5. #define SCAN_TIME  1    
    


  6. 

  7. #define VOICE_TIME   50     //蜂鸣器一次“滴”的声音长度 50ms  
    


  8. 

  9. void T0_time();
    

  10. void SystemInitial(void) ;
    

  11. void Delay(unsigned long u32DelayTime) ;
    

  12. void PeripheralInitial(void) ;
    


  13. 

  14. void KeyScan(void);  
    

  15. void KeyTask(void);  
    


  16. 

  17. void VoiceScan(void);  //蜂鸣器的驱动函数
    

  18. void DisplayScan(void);  //底层显示的驱动函数  
    

  19. void DisplayTask(void);  //上层显示的任务函数
    


  20. 

  21. void RunTask(void);  //倒计时的应用程序
    


  22. 

  23. void BeepOpen(void);   
    

  24. void BeepClose(void); 
    


  25. 

  26. sbit KEY_INPUT1=P2^2;  
    

  27. sbit KEY_INPUT2=P2^1;  
    


  28. 

  29. sbit P1_0=P1^0;  
    

  30. sbit P1_1=P1^1;  
    

  31. sbit P1_2=P1^2;  
    

  32. sbit P1_3=P1^3; 
    


  33. 

  34. sbit P3_4=P3^4; 
    


  35. 

  36. //数码管转换表
    

  37. code unsigned char Cu8DigTable[]=
    

  38. {
    

  39. 0x3f,  //0       序号0
    

  40. 0x06,  //1       序号1
    

  41. 0x5b,  //2       序号2
    

  42. 0x4f,  //3       序号3
    

  43. 0x66,  //4       序号4
    

  44. 0x6d,  //5       序号5
    

  45. 0x7d,  //6       序号6
    

  46. 0x07,  //7       序号7
    

  47. 0x7f,  //8       序号8
    

  48. 0x6f,  //9       序号9
    

  49. 0x00,  //不显示  序号10
    

  50. };
    


  51. 

  52. //数码管底层驱动扫描的软件定时器
    

  53. volatile unsigned char vGu8ScanTimerFlag=0;  
    

  54. volatile unsigned int vGu16ScanTimerCnt=0;  
    


  55. 

  56. //倒计时的软件定时器，注意，这里是unsigned long类型，范围是0到4294967295毫秒
    

  57. volatile unsigned char vGu8CountdownTimerFlag=0;  
    

  58. volatile unsigned long vGu32CountdownTimerCnt=10000;  //开机默认显示初始值10.000秒
    


  59. 

  60. //数码管上层每10ms就定时刷新一次显示的软件定时器。用于及时更新显示秒表当前的实时数值
    

  61. volatile unsigned char vGu8UpdateTimerFlag=0;  
    

  62. volatile unsigned int vGu16UpdateTimerCnt=0;  
    


  63. 

  64. //蜂鸣器的软件定时器
    

  65. volatile unsigned char vGu8BeepTimerFlag=0;  
    

  66. volatile unsigned int vGu16BeepTimerCnt=0;  
    


  67. 

  68. unsigned char Gu8RunStart=0;  //应用程序的总启动
    

  69. unsigned char Gu8RunStep=0;  //应用程序的总运行步骤。建议跟vGu8RunStart成双成对出现
    

  70. unsigned char Gu8RunStatus=0; //当前倒计时的状态。0代表停止，1代表正在工作中
    


  71. 

  72. unsigned char Gu8WdUpdate=1;  //开机默认整屏更新一次显示。此变量在显示框架中是非常重要的变量
    


  73. 

  74. volatile unsigned char vGu8Display_Righ_4=1;  //显示“1”，跟vGu32CountdownTimerCnt高位一致
    

  75. volatile unsigned char vGu8Display_Righ_3=0;  
    

  76. volatile unsigned char vGu8Display_Righ_2=0;  
    

  77. volatile unsigned char vGu8Display_Righ_1=0;  
    


  78. 

  79. volatile unsigned char vGu8Display_Righ_Dot_4=0;  
    

  80. volatile unsigned char vGu8Display_Righ_Dot_3=1;    //开机默认保留显示2个小数点 
    

  81. volatile unsigned char vGu8Display_Righ_Dot_2=0;  
    

  82. volatile unsigned char vGu8Display_Righ_Dot_1=0;  
    


  83. 

  84. volatile unsigned char vGu8KeySec=0;  
    


  85. 

  86. void main() 
    

  87. {
    

  88. SystemInitial();            
    

  89. Delay(10000);               
    

  90. PeripheralInitial();      
    

  91.     while(1)  
    

  92. {  
    

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

  94. DisplayTask();  //数码管显示的上层任务函数
    

  95. RunTask();      //倒计时的应用程序
    

  96.     }
    

  97. }
    


  98. 

  99. void KeyTask(void)    //按键的任务函数
    

  100. {
    

  101. if(0==vGu8KeySec)
    

  102. {
    

  103. return; 
    

  104. }
    


  105. 

  106. switch(vGu8KeySec) 
    

  107. {
    

  108.    case 1:     //复位按键
    


  109. 

  110. Gu8RunStatus=0; //倒计时返回停止的状态
    


  111. 

  112. Gu8RunStart=0;  //倒计时的运行步骤的停止
    

  113.             Gu8RunStep=0;  //总运行步骤归零。建议跟vGu8RunStart成双成对出现
    


  114. 

  115. vGu8CountdownTimerFlag=0;    //禁止倒计时开始(而Gu8RunStart是启动开关，不矛盾)
    

  116. vGu32CountdownTimerCnt=10000;   //倒计时的软件定时器恢复初始值10.000秒
    


  117. 

  118.             Gu8WdUpdate=1;  //整屏更新一次显示
    


  119. 

  120. vGu8KeySec=0;  
    

  121. break;
    


  122. 

  123.    case 2:     //启动的按键
    

  124.         if(0==Gu8RunStatus) //在停止状态下
    

  125.         {
    


  126. 

  127. vGu8CountdownTimerFlag=0; 
    

  128. vGu32CountdownTimerCnt=10000;  //初始值是10.000秒
    

  129. vGu8CountdownTimerFlag=1;      //允许倒计时的软件定时器的启动
    


  130. 

  131.             Gu8RunStatus=1;  //倒计时处于工作状态（并且，这一瞬间才正式启动倒计时）
    


  132. 

  133. Gu8RunStart=1;   //倒计时的运行步骤的总开关开启
    

  134.                 Gu8RunStep=0;    //总运行步骤归零。建议跟vGu8RunStart成双成对出现
    


  135. 

  136.             Gu8WdUpdate=1;  //整屏更新一次显示，确保在启动的时候能显示到最新的数据
    

  137. }
    


  138. 


  139. 

  140. vGu8KeySec=0; 
    

  141. break;
    


  142. 

  143. }
    

  144. }
    


  145. 

  146. void DisplayTask(void) //数码管显示的上层任务函数
    

  147. {
    

  148. //需要借用的中间变量，用来拆分数据位。
    

  149. static unsigned char Su8Temp_4,Su8Temp_3,Su8Temp_2,Su8Temp_1; //需要借用的中间变量
    


  150. 

  151. if(1==Gu8WdUpdate) //如果需要整屏更新
    

  152. {
    

  153. Gu8WdUpdate=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
    


  154. 

  155.           //先分解数据，注意，这里分解的时候，“先整除后求余”必须用一行代码一气呵成，不能拆
    

  156.           //分成两行代码，否则会有隐患会有bug。除非，把四个临时变都改成unsigned long类型。
    


  157. 

  158.           //Su8Temp_4提取“十秒”位。
    

  159. Su8Temp_4=vGu32CountdownTimerCnt/10000%10; //实际精度是0.001秒,但显示精度是0.01秒
    


  160. 

  161.          //Su8Temp_3提取“个秒”位。
    

  162. Su8Temp_3=vGu32CountdownTimerCnt/1000%10; //实际精度是0.001秒,但显示精度是0.01秒
    


  163. 

  164.          //Su8Temp_2提取“百毫秒”位。
    

  165. Su8Temp_2=vGu32CountdownTimerCnt/100%10; //实际精度是0.001秒,但显示精度是0.01秒
    


  166. 

  167.           //Su8Temp_1提取“十毫秒”位。
    

  168. Su8Temp_1=vGu32CountdownTimerCnt/10%10; //实际精度是0.001秒,但显示精度是0.01秒
    


  169. 

  170.           //判断数据范围，来决定最高位数码管是否需要显示。
    

  171.           if(vGu32CountdownTimerCnt<10000) //10.000秒。实际4位数码管最大只能显示99.99秒
    

  172.           {
    

  173.              Su8Temp_4=10;  //在数码管转换表里，10代表一个“不显示”的数据
    

  174. }
    


  175. 

  176. //上面先分解数据之后，再过渡需要显示的数据到底层驱动变量里，让过渡的时间越短越好
    

  177. vGu8Display_Righ_4=Su8Temp_4;  //过渡需要显示的数据到底层驱动变量
    

  178. vGu8Display_Righ_3=Su8Temp_3;  
    

  179. vGu8Display_Righ_2=Su8Temp_2;  
    

  180. vGu8Display_Righ_1=Su8Temp_1;  
    


  181. 

  182. vGu8Display_Righ_Dot_4=0;  
    

  183. vGu8Display_Righ_Dot_3=1;   //保留显示2位小数点
    

  184. vGu8Display_Righ_Dot_2=0;  
    

  185. vGu8Display_Righ_Dot_1=0;  
    


  186. 

  187. }
    

  188. }
    


  189. 

  190. void RunTask(void)  //倒计时的应用程序
    

  191. { 
    

  192. if(0==Gu8RunStart) 
    

  193. {
    

  194.    return;  // 如果总开关处于停止状态，则直接退出当前函数，不执行该函数以下的其它代码
    

  195. }
    


  196. 

  197. switch(Gu8RunStep)
    

  198. {
    

  199.     case 0:  //在这个步骤里，主要用来初始化一些参数
    


  200. 

  201. vGu8UpdateTimerFlag=0;
    

  202. vGu16UpdateTimerCnt=10;  //每10ms更新显示一次当前倒计时的时间
    

  203. vGu8UpdateTimerFlag=1;
    


  204. 

  205. Gu8RunStep=1; //跳转到每10ms更新显示一次的步骤里
    

  206. break;
    


  207. 

  208.     case 1:  //每10ms更新一次显示，确保实时显示当前倒计时的时间
    

  209.        if(0==vGu16UpdateTimerCnt) //每10ms更新显示一次当前倒计时的时间
    

  210.        {
    


  211. 


  212. 

  213.     vGu8UpdateTimerFlag=0;
    

  214. vGu16UpdateTimerCnt=10;  //重置定时器，为下一个10ms更新做准备
    

  215. vGu8UpdateTimerFlag=1;
    


  216. 

  217.             Gu8WdUpdate=1;  //整屏更新一次显示当前倒计时的时间
    


  218. 

  219.             if(0==vGu32CountdownTimerCnt) //如果倒计时的时间到，则跳转到结束的步骤
    

  220.             {
    

  221. Gu8RunStep=2; //跳转到倒计时结束的步骤
    

  222. }
    


  223. 

  224. }
    

  225. break;
    


  226. 

  227. case 2:  //倒计时结束的步骤
    

  228. //Gu8RunStatus=0; //这行代码注释掉，让每次新启动之前都必须按一次K1复位按键才有效
    


  229. 

  230. Gu8RunStart=0;  //倒计时的运行步骤的停止
    

  231.             Gu8RunStep=0;   //总运行步骤归零。建议跟vGu8RunStart成双成对出现
    


  232. 

  233. vGu8BeepTimerFlag=0;  
    

  234. vGu16BeepTimerCnt=VOICE_TIME;  //蜂鸣器发出“滴”一声
    

  235. vGu8BeepTimerFlag=1;  
    


  236. 

  237.         Gu8WdUpdate=1;  //整屏更新一次显示当前倒计时的时间
    


  238. 

  239. break;
    


  240. 

  241. }
    


  242. 

  243. }
    


  244. 


  245. 

  246. void KeyScan(void)  //按键底层的驱动扫描函数，放在定时中断函数里
    

  247. {
    

  248.    static unsigned char Su8KeyLock1; 
    

  249.    static unsigned int  Su16KeyCnt1; 
    

  250.    static unsigned char Su8KeyLock2; 
    

  251.    static unsigned int  Su16KeyCnt2; 
    


  252. 

  253.    if(0!=KEY_INPUT1)
    

  254.    {
    

  255.       Su8KeyLock1=0; 
    

  256.       Su16KeyCnt1=0;   
    

  257.    }
    

  258.    else if(0==Su8KeyLock1)
    

  259.    {
    

  260.       Su16KeyCnt1++;
    

  261.       if(Su16KeyCnt1>=KEY_FILTER_TIME) 
    

  262.       {
    

  263.          Su8KeyLock1=1;  
    

  264.          vGu8KeySec=1;    
    

  265.       }
    

  266.    }
    


  267. 

  268.    if(0!=KEY_INPUT2)
    

  269.    {
    

  270.       Su8KeyLock2=0; 
    

  271.       Su16KeyCnt2=0;       
    

  272.    }
    

  273.    else if(0==Su8KeyLock2)
    

  274.    {
    

  275.       Su16KeyCnt2++; 
    

  276.       if(Su16KeyCnt2>=KEY_FILTER_TIME) 
    

  277.       {
    

  278.          Su8KeyLock2=1;  
    

  279.          vGu8KeySec=2;    
    

  280.       }
    

  281.    }
    

  282. }
    


  283. 

  284. void DisplayScan(void)    //数码管底层的驱动扫描函数，放在定时中断函数里
    

  285. {
    

  286. static unsigned char Su8GetCode;  
    

  287. static unsigned char Su8ScanStep=1;  
    


  288. 

  289. if(0==vGu16ScanTimerCnt)  
    

  290. {
    


  291. 


  292. 

  293.     P0=0x00; 
    

  294. P1_0=1;  
    

  295. P1_1=1;  
    

  296. P1_2=1;  
    

  297. P1_3=1;  
    


  298. 

  299.     switch(Su8ScanStep)
    

  300. {
    

  301.        case 1: 
    

  302. Su8GetCode=Cu8DigTable[vGu8Display_Righ_1]; 
    


  303. 

  304. if(1==vGu8Display_Righ_Dot_1) 
    

  305. {
    

  306. Su8GetCode=Su8GetCode|0x80;  
    

  307. }
    

  308.     P0=Su8GetCode; 
    

  309. P1_0=0; 
    

  310. P1_1=1;  
    

  311. P1_2=1;  
    

  312. P1_3=1;            
    

  313. break;
    


  314. 

  315.        case 2: 
    

  316. Su8GetCode=Cu8DigTable[vGu8Display_Righ_2]; 
    

  317. if(1==vGu8Display_Righ_Dot_2) 
    

  318. {
    

  319. Su8GetCode=Su8GetCode|0x80;  
    

  320. }
    

  321.     P0=Su8GetCode;
    

  322. P1_0=1;  
    

  323. P1_1=0; 
    

  324. P1_2=1; 
    

  325. P1_3=1;          
    

  326. break;
    


  327. 

  328.        case 3: 
    

  329. Su8GetCode=Cu8DigTable[vGu8Display_Righ_3];
    

  330. if(1==vGu8Display_Righ_Dot_3) 
    

  331. {
    

  332. Su8GetCode=Su8GetCode|0x80;  
    

  333. }
    

  334.     P0=Su8GetCode;
    

  335. P1_0=1;  
    

  336. P1_1=1;  
    

  337. P1_2=0;  
    

  338. P1_3=1;         
    

  339. break;
    


  340. 

  341.        case 4: 
    

  342. Su8GetCode=Cu8DigTable[vGu8Display_Righ_4]; 
    

  343. if(1==vGu8Display_Righ_Dot_4) 
    

  344. {
    

  345. Su8GetCode=Su8GetCode|0x80;  
    

  346. }
    

  347.     P0=Su8GetCode; 
    

  348. P1_0=1;  
    

  349. P1_1=1;  
    

  350. P1_2=1;  
    

  351. P1_3=0;           
    

  352. break;
    


  353. 

  354. }
    


  355. 

  356. Su8ScanStep++;
    

  357. if(Su8ScanStep>4) 
    

  358. {
    

  359. Su8ScanStep=1;
    

  360. }
    


  361. 

  362. vGu8ScanTimerFlag=0; 
    

  363. vGu16ScanTimerCnt=SCAN_TIME;  
    

  364. vGu8ScanTimerFlag=1;  
    

  365. }
    

  366. }
    


  367. 


  368. 

  369. void VoiceScan(void) //蜂鸣器的驱动函数
    

  370. {
    


  371. 

  372.           static unsigned char Su8Lock=0;  
    


  373. 

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

  375.           {
    

  376.                   if(0==Su8Lock)
    

  377.                   {
    

  378.                    Su8Lock=1;  
    

  379. BeepOpen(); 
    

  380.      }
    

  381.     else  
    

  382. {     
    


  383. 

  384.                        vGu16BeepTimerCnt--;         
    


  385. 

  386.                    if(0==vGu16BeepTimerCnt)
    

  387.                    {
    

  388.                            Su8Lock=0;     
    

  389. BeepClose();  
    

  390.                    }
    


  391. 

  392. }
    

  393.           }         
    

  394. }
    


  395. 

  396. void BeepOpen(void)
    

  397. {
    

  398. P3_4=0;  
    

  399. }
    


  400. 

  401. void BeepClose(void)
    

  402. {
    

  403. P3_4=1;  
    

  404. }
    


  405. 

  406. void T0_time() interrupt 1     
    

  407. {
    

  408. VoiceScan();    //蜂鸣器的驱动函数
    

  409. KeyScan();      //按键底层的驱动扫描函数
    

  410. DisplayScan();  //数码管底层的驱动扫描函数
    


  411. 

  412. if(1==vGu8ScanTimerFlag&&vGu16ScanTimerCnt>0)  
    

  413. {
    

  414. vGu16ScanTimerCnt--;  //递减式的软件定时器
    

  415. }
    


  416. 

  417. //每10ms就定时更新一次显示的软件定时器
    

  418. if(1==vGu8UpdateTimerFlag&&vGu16UpdateTimerCnt>0)  
    

  419. {
    

  420. vGu16UpdateTimerCnt--;  //递减式的软件定时器
    

  421. }
    


  422. 

  423. //倒计时实际走的时间的软件定时器，注意，这里还附加了启动状态的条件“&&1==Gu8RunStatus”
    

  424. if(1==vGu8CountdownTimerFlag&&vGu32CountdownTimerCnt>0&&1==Gu8RunStatus) 
    

  425. {
    

  426. vGu32CountdownTimerCnt--;  //递减式的软件定时器
    

  427. }
    


  428. 


  429. 

  430. TH0=0xfc;   
    

  431. TL0=0x66;   
    

  432. }
    


  433. 


  434. 

  435. void SystemInitial(void) 
    

  436. {
    

  437. P0=0x00;
    

  438. P1_0=1;  
    

  439. P1_1=1;  
    

  440. P1_2=1;  
    

  441. P1_3=1;  
    


  442. 

  443. TMOD=0x01;  
    

  444. TH0=0xfc;   
    

  445. TL0=0x66;   
    

  446. EA=1;       
    

  447. ET0=1;      
    

  448. TR0=1;      
    

  449. }
    


  450. 

  451. void Delay(unsigned long u32DelayTime) 
    

  452. {
    

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

  454. }
    


  455. 

  456. void PeripheralInitial(void) 
    

  457. {
    


  458. 

  459. }


本帖子中包含更多资源

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

×
回复

收藏269 举报

天命风流 发表于 2018-5-3 11:26 | 显示全部楼层
厉害啊
回复

收藏269 举报

maglasbirl 发表于 2018-5-4 11:35 | 显示全部楼层
怎么收藏主题啊？
回复

收藏269 举报

凡逸浩 发表于 2018-5-10 15:15 | 显示全部楼层
大概看了一下，还是蛮有用的
回复

收藏269 举报

 楼主| jianhong_wu 发表于 2018-5-12 10:39 | 显示全部楼层
第一百一十七节： 按键切换数码管窗口来设置参数。

【117.1   按键切换数码管窗口来设置参数。】
     
                上图117.1.1  数码管




                上图117.1.2  独立按键

         
                上图117.1.3  有源蜂鸣器

        单片机是“数据”驱动型的。按什么逻辑跑，以什么方式跑，都是“数据”决定的。人机交互的核心就是“人”以什么渠道去更改“机”内部的某些“数据”。在程序框架层面，按键更改或者编辑某些数据，我的核心思路都是“在某个窗口下去更改某个特定的数据”，如果某个窗口的数据很多，就需要在此窗口下进一步细分，细分为“某个窗口下的某个局部（子菜单、光标选择）”。可见，“窗口”是支点，“局部”是支点中再细分出来的支点。窗口对应一个名叫 “窗口选择”的全局变量Gu8Wd，局部（子菜单、光标选择）对应一个名叫“局部选择”的全局变量Gu8Part。数据发生变化的时候，才需要更新显示到数码管上，平时不用一直更新显示，因此，与“窗口选择”Gu8Wd还对应一个名叫“整屏更新”的全局变量Gu8WdUpdate，与“局部选择”Gu8Part还对应一个名叫“局部更新”的全局变量Gu8PartUpdate。本节的小项目程序只用到“窗口”，没有用到“局部”。
        本节小项目的程序功能，利用按键与数码管的人机交互，可以对单片机内部三个参数Gu8SetData_1，Gu8SetData_2，Gu8SetData_3进行编辑。这三个参数分别在三个窗口下进行编辑，这三个窗口是数码管显示“1-XX”，“2-YY”，“3-ZZ”。其中，XX代表Gu8SetData_1数据，YY代表Gu8SetData_2数据，ZZ代表Gu8SetData_3数据，这三个数据的范围是从0到99。K1是窗口切换按键，每按一次，窗口会在“1-XX”，“2-YY”，“3-ZZ”三个窗口之间进行切换。K2是数字累加按键，每按一次，显示的数字会累加1。K3是数字递减按键，每按一次，显示的数字会递减1。代码如下：

复制
  1. #include "REG52.H"  
    


  2. 

  3. #define KEY_FILTER_TIME  25 
    

  4. #define SCAN_TIME  1    
    

  5. #define VOICE_TIME   50    
    


  6. 

  7. void T0_time();
    

  8. void SystemInitial(void) ;
    

  9. void Delay(unsigned long u32DelayTime) ;
    

  10. void PeripheralInitial(void) ;
    


  11. 

  12. void KeyScan(void);  
    

  13. void KeyTask(void);  
    


  14. 

  15. void VoiceScan(void);  
    

  16. void DisplayScan(void);  
    

  17. void DisplayTask(void);  //上层显示的任务函数
    

  18. void Wd1(void);   //窗口1显示函数
    

  19. void Wd2(void);   //窗口2显示函数
    

  20. void Wd3(void);   //窗口3显示函数
    


  21. 

  22. void BeepOpen(void);   
    

  23. void BeepClose(void); 
    


  24. 

  25. sbit KEY_INPUT1=P2^2;  
    

  26. sbit KEY_INPUT2=P2^1;  
    

  27. sbit KEY_INPUT3=P2^0;  
    


  28. 

  29. sbit P1_0=P1^0;  
    

  30. sbit P1_1=P1^1;  
    

  31. sbit P1_2=P1^2;  
    

  32. sbit P1_3=P1^3; 
    


  33. 

  34. sbit P3_4=P3^4; 
    


  35. 

  36. //数码管转换表
    

  37. code unsigned char Cu8DigTable[]=
    

  38. {
    

  39. 0x3f,  //0       序号0
    

  40. 0x06,  //1       序号1
    

  41. 0x5b,  //2       序号2
    

  42. 0x4f,  //3       序号3
    

  43. 0x66,  //4       序号4
    

  44. 0x6d,  //5       序号5
    

  45. 0x7d,  //6       序号6
    

  46. 0x07,  //7       序号7
    

  47. 0x7f,  //8       序号8
    

  48. 0x6f,  //9       序号9
    

  49. 0x00,  //不显示  序号10
    

  50. 0x40,  //横杠-   序号11
    

  51. };
    


  52. 

  53. volatile unsigned char vGu8ScanTimerFlag=0;  
    

  54. volatile unsigned int vGu16ScanTimerCnt=0;  
    


  55. 

  56. volatile unsigned char vGu8BeepTimerFlag=0;  
    

  57. volatile unsigned int vGu16BeepTimerCnt=0;  
    


  58. 

  59. unsigned char Gu8SetData_1=0; //单片机内部第1个可编辑的参数
    

  60. unsigned char Gu8SetData_2=0; //单片机内部第2个可编辑的参数
    

  61. unsigned char Gu8SetData_3=0; //单片机内部第3个可编辑的参数
    


  62. 

  63. unsigned char Gu8Wd=1;   //窗口选择变量。人机交互程序框架的支点。初始化开机后显示第1个窗口。
    

  64. unsigned char Gu8WdUpdate=1;  //整屏更新变量。初始化为1开机后整屏更新一次显示。
    


  65. 

  66. volatile unsigned char vGu8Display_Righ_4=1;  //显示窗口“1”
    

  67. volatile unsigned char vGu8Display_Righ_3=11; //显示横杠“-”  
    

  68. volatile unsigned char vGu8Display_Righ_2=0;  //显示十位数值“0”
    

  69. volatile unsigned char vGu8Display_Righ_1=0;  //显示个位数值“0”
    


  70. 

  71. volatile unsigned char vGu8Display_Righ_Dot_4=0;  
    

  72. volatile unsigned char vGu8Display_Righ_Dot_3=0;     
    

  73. volatile unsigned char vGu8Display_Righ_Dot_2=0;  
    

  74. volatile unsigned char vGu8Display_Righ_Dot_1=0;  
    


  75. 

  76. volatile unsigned char vGu8KeySec=0;  
    


  77. 

  78. void main() 
    

  79. {
    

  80. SystemInitial();            
    

  81. Delay(10000);               
    

  82. PeripheralInitial();      
    

  83.     while(1)  
    

  84. {  
    

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

  86. DisplayTask();  //数码管显示的上层任务函数
    

  87.     }
    

  88. }
    


  89. 

  90. void KeyTask(void)    //按键的任务函数
    

  91. {
    

  92. if(0==vGu8KeySec)
    

  93. {
    

  94. return; 
    

  95. }
    


  96. 

  97. switch(vGu8KeySec) 
    

  98. {
    

  99.    case 1:     //窗口切换的按键
    

  100. Gu8Wd++;  //窗口切换到下一个窗口
    

  101. if(Gu8Wd>3)  //一共3个窗口。切换第3个窗口之后，继续返回到第1个窗口
    

  102. {
    

  103. Gu8Wd=1;   //返回到第1个窗口
    

  104. }
    

  105.             Gu8WdUpdate=1;  //整屏更新一次显示
    


  106. 

  107. vGu8BeepTimerFlag=0;  
    

  108. vGu16BeepTimerCnt=VOICE_TIME;  //蜂鸣器发出“滴”一声
    

  109. vGu8BeepTimerFlag=1;  
    


  110. 

  111. vGu8KeySec=0;  
    

  112. break;
    


  113. 

  114.    case 2:     //累加的按键
    

  115.         switch(Gu8Wd)  //以窗口选择Gu8Wd为支点，去编辑对应的数据。又一次用到switch语句
    

  116.         {
    

  117.              case 1:     //在第1个窗口下编辑Gu8SetData_1数据
    

  118.                   Gu8SetData_1++;
    

  119.                   if(Gu8SetData_1>99) //把最大范围限定在99
    

  120. {
    

  121. Gu8SetData_1=99;
    

  122. }
    

  123.                       Gu8WdUpdate=1;  //整屏更新一次显示
    

  124.                   break;
    


  125. 

  126.              case 2:     //在第2个窗口下编辑Gu8SetData_2数据
    

  127.                   Gu8SetData_2++;
    

  128.                   if(Gu8SetData_2>99) //把最大范围限定在99
    

  129. {
    

  130. Gu8SetData_2=99;
    

  131. }
    

  132.                       Gu8WdUpdate=1;  //整屏更新一次显示
    

  133.                   break;
    


  134. 

  135.              case 3:     //在第3个窗口下编辑Gu8SetData_3数据
    

  136.                   Gu8SetData_3++;
    

  137.                   if(Gu8SetData_3>99) //把最大范围限定在99
    

  138. {
    

  139. Gu8SetData_3=99;
    

  140. }
    

  141.                       Gu8WdUpdate=1;  //整屏更新一次显示
    

  142.                   break;
    

  143. }
    


  144. 

  145. vGu8BeepTimerFlag=0;  
    

  146. vGu16BeepTimerCnt=VOICE_TIME;  //蜂鸣器发出“滴”一声
    

  147. vGu8BeepTimerFlag=1;  
    


  148. 

  149. vGu8KeySec=0;  
    

  150. break;
    


  151. 

  152.    case 3:     //递减的按键
    

  153.         switch(Gu8Wd)  //以窗口选择Gu8Wd为支点，去编辑对应的数据。又一次用到switch语句
    

  154.         {
    

  155.              case 1:     //在第1个窗口下编辑Gu8SetData_1数据
    

  156.                   if(Gu8SetData_1>0) //把最小范围限定在0
    

  157. {
    

  158. Gu8SetData_1--;
    

  159. }
    

  160.                       Gu8WdUpdate=1;  //整屏更新一次显示
    

  161.                   break;
    


  162. 

  163.              case 2:     //在第2个窗口下编辑Gu8SetData_2数据
    

  164.                   if(Gu8SetData_2>0) //把最小范围限定在0
    

  165. {
    

  166. Gu8SetData_2--;
    

  167. }
    

  168.                       Gu8WdUpdate=1;  //整屏更新一次显示
    

  169.                   break;
    


  170. 

  171.              case 3:     //在第3个窗口下编辑Gu8SetData_3数据
    

  172.                   if(Gu8SetData_3>0) //把最小范围限定在0
    

  173. {
    

  174. Gu8SetData_3--;
    

  175. }
    

  176.                       Gu8WdUpdate=1;  //整屏更新一次显示
    

  177.                   break;
    

  178. }
    


  179. 

  180. vGu8BeepTimerFlag=0;  
    

  181. vGu16BeepTimerCnt=VOICE_TIME;  //蜂鸣器发出“滴”一声
    

  182. vGu8BeepTimerFlag=1;  
    


  183. 

  184. vGu8KeySec=0;  
    

  185. break;
    

  186. }
    

  187. }
    


  188. 

  189. void DisplayTask(void) //数码管显示的上层任务函数
    

  190. {
    

  191.   switch(Gu8Wd)  //以窗口选择Gu8Wd为支点，去执行对应的窗口显示函数。又一次用到switch语句
    

  192. { 
    

  193.     case 1:
    

  194.         Wd1();   //窗口1显示函数
    

  195.         break;
    

  196.     case 2:
    

  197.         Wd2();   //窗口2显示函数
    

  198.         break;
    

  199.     case 3:
    

  200.         Wd3();   //窗口3显示函数
    

  201.         break;
    

  202. }
    


  203. 

  204. }
    


  205. 

  206. void Wd1(void)   //窗口1显示函数
    

  207. {
    

  208. //需要借用的中间变量，用来拆分数据位。
    

  209. static unsigned char Su8Temp_4,Su8Temp_3,Su8Temp_2,Su8Temp_1; //需要借用的中间变量
    


  210. 

  211. if(1==Gu8WdUpdate) //如果需要整屏更新
    

  212. {
    

  213. Gu8WdUpdate=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
    


  214. 

  215. Su8Temp_4=1;  //窗口“1”
    

  216. Su8Temp_3=11; //横杠“-”
    

  217. Su8Temp_2=Gu8SetData_1/10%10; //十位数值
    

  218. Su8Temp_1=Gu8SetData_1/1%10;  //个位数值
    


  219. 

  220. //上面先分解数据之后，再过渡需要显示的数据到底层驱动变量里，让过渡的时间越短越好
    

  221. vGu8Display_Righ_4=Su8Temp_4;  //过渡需要显示的数据到底层驱动变量
    

  222. vGu8Display_Righ_3=Su8Temp_3;  
    

  223. vGu8Display_Righ_2=Su8Temp_2;  
    

  224. vGu8Display_Righ_1=Su8Temp_1;  
    


  225. 

  226. //不显示任何一个小数点
    

  227. vGu8Display_Righ_Dot_4=0;  
    

  228. vGu8Display_Righ_Dot_3=0;  
    

  229. vGu8Display_Righ_Dot_2=0;  
    

  230. vGu8Display_Righ_Dot_1=0;  
    

  231. }
    

  232. }
    


  233. 

  234. void Wd2(void)   //窗口2显示函数
    

  235. {
    

  236. //需要借用的中间变量，用来拆分数据位。
    

  237. static unsigned char Su8Temp_4,Su8Temp_3,Su8Temp_2,Su8Temp_1; //需要借用的中间变量
    


  238. 

  239. if(1==Gu8WdUpdate) //如果需要整屏更新
    

  240. {
    

  241. Gu8WdUpdate=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
    


  242. 

  243. Su8Temp_4=2;  //窗口“2”
    

  244. Su8Temp_3=11; //横杠“-”
    

  245. Su8Temp_2=Gu8SetData_2/10%10; //十位数值
    

  246. Su8Temp_1=Gu8SetData_2/1%10;  //个位数值
    


  247. 

  248. //上面先分解数据之后，再过渡需要显示的数据到底层驱动变量里，让过渡的时间越短越好
    

  249. vGu8Display_Righ_4=Su8Temp_4;  //过渡需要显示的数据到底层驱动变量
    

  250. vGu8Display_Righ_3=Su8Temp_3;  
    

  251. vGu8Display_Righ_2=Su8Temp_2;  
    

  252. vGu8Display_Righ_1=Su8Temp_1;  
    


  253. 

  254. //不显示任何一个小数点
    

  255. vGu8Display_Righ_Dot_4=0;  
    

  256. vGu8Display_Righ_Dot_3=0;  
    

  257. vGu8Display_Righ_Dot_2=0;  
    

  258. vGu8Display_Righ_Dot_1=0;  
    

  259. }
    

  260. }
    


  261. 

  262. void Wd3(void)   //窗口3显示函数
    

  263. {
    

  264. //需要借用的中间变量，用来拆分数据位。
    

  265. static unsigned char Su8Temp_4,Su8Temp_3,Su8Temp_2,Su8Temp_1; //需要借用的中间变量
    


  266. 

  267. if(1==Gu8WdUpdate) //如果需要整屏更新
    

  268. {
    

  269. Gu8WdUpdate=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
    


  270. 

  271. Su8Temp_4=3;  //窗口“3”
    

  272. Su8Temp_3=11; //横杠“-”
    

  273. Su8Temp_2=Gu8SetData_3/10%10; //十位数值
    

  274. Su8Temp_1=Gu8SetData_3/1%10;  //个位数值
    


  275. 

  276. //上面先分解数据之后，再过渡需要显示的数据到底层驱动变量里，让过渡的时间越短越好
    

  277. vGu8Display_Righ_4=Su8Temp_4;  //过渡需要显示的数据到底层驱动变量
    

  278. vGu8Display_Righ_3=Su8Temp_3;  
    

  279. vGu8Display_Righ_2=Su8Temp_2;  
    

  280. vGu8Display_Righ_1=Su8Temp_1;  
    


  281. 

  282. //不显示任何一个小数点
    

  283. vGu8Display_Righ_Dot_4=0;  
    

  284. vGu8Display_Righ_Dot_3=0;  
    

  285. vGu8Display_Righ_Dot_2=0;  
    

  286. vGu8Display_Righ_Dot_1=0;  
    

  287. }
    

  288. }
    


  289. 

  290. void KeyScan(void)  //按键底层的驱动扫描函数，放在定时中断函数里
    

  291. {
    

  292.    static unsigned char Su8KeyLock1; 
    

  293.    static unsigned int  Su16KeyCnt1; 
    

  294.    static unsigned char Su8KeyLock2; 
    

  295.    static unsigned int  Su16KeyCnt2; 
    

  296.     static unsigned char Su8KeyLock3; 
    

  297.    static unsigned int  Su16KeyCnt3; 
    


  298. 

  299.    if(0!=KEY_INPUT1)
    

  300.    {
    

  301.       Su8KeyLock1=0; 
    

  302.       Su16KeyCnt1=0;   
    

  303.    }
    

  304.    else if(0==Su8KeyLock1)
    

  305.    {
    

  306.       Su16KeyCnt1++;
    

  307.       if(Su16KeyCnt1>=KEY_FILTER_TIME) 
    

  308.       {
    

  309.          Su8KeyLock1=1;  
    

  310.          vGu8KeySec=1;    
    

  311.       }
    

  312.    }
    


  313. 

  314.    if(0!=KEY_INPUT2)
    

  315.    {
    

  316.       Su8KeyLock2=0; 
    

  317.       Su16KeyCnt2=0;       
    

  318.    }
    

  319.    else if(0==Su8KeyLock2)
    

  320.    {
    

  321.       Su16KeyCnt2++; 
    

  322.       if(Su16KeyCnt2>=KEY_FILTER_TIME) 
    

  323.       {
    

  324.          Su8KeyLock2=1;  
    

  325.          vGu8KeySec=2;    
    

  326.       }
    

  327.    }
    


  328. 

  329.    if(0!=KEY_INPUT3)
    

  330.    {
    

  331.       Su8KeyLock3=0; 
    

  332.       Su16KeyCnt3=0;       
    

  333.    }
    

  334.    else if(0==Su8KeyLock3)
    

  335.    {
    

  336.       Su16KeyCnt3++; 
    

  337.       if(Su16KeyCnt3>=KEY_FILTER_TIME) 
    

  338.       {
    

  339.          Su8KeyLock3=1;  
    

  340.          vGu8KeySec=3;    
    

  341.       }
    

  342.    }
    


  343. 

  344. }
    


  345. 

  346. void DisplayScan(void)    //数码管底层的驱动扫描函数，放在定时中断函数里
    

  347. {
    

  348. static unsigned char Su8GetCode;  
    

  349. static unsigned char Su8ScanStep=1;  
    


  350. 

  351. if(0==vGu16ScanTimerCnt)  
    

  352. {
    


  353. 


  354. 

  355.     P0=0x00; 
    

  356. P1_0=1;  
    

  357. P1_1=1;  
    

  358. P1_2=1;  
    

  359. P1_3=1;  
    


  360. 

  361.     switch(Su8ScanStep)
    

  362. {
    

  363.        case 1: 
    

  364. Su8GetCode=Cu8DigTable[vGu8Display_Righ_1]; 
    


  365. 

  366. if(1==vGu8Display_Righ_Dot_1) 
    

  367. {
    

  368. Su8GetCode=Su8GetCode|0x80;  
    

  369. }
    

  370.     P0=Su8GetCode; 
    

  371. P1_0=0; 
    

  372. P1_1=1;  
    

  373. P1_2=1;  
    

  374. P1_3=1;            
    

  375. break;
    


  376. 

  377.        case 2: 
    

  378. Su8GetCode=Cu8DigTable[vGu8Display_Righ_2]; 
    

  379. if(1==vGu8Display_Righ_Dot_2) 
    

  380. {
    

  381. Su8GetCode=Su8GetCode|0x80;  
    

  382. }
    

  383.     P0=Su8GetCode;
    

  384. P1_0=1;  
    

  385. P1_1=0; 
    

  386. P1_2=1; 
    

  387. P1_3=1;          
    

  388. break;
    


  389. 

  390.        case 3: 
    

  391. Su8GetCode=Cu8DigTable[vGu8Display_Righ_3];
    

  392. if(1==vGu8Display_Righ_Dot_3) 
    

  393. {
    

  394. Su8GetCode=Su8GetCode|0x80;  
    

  395. }
    

  396.     P0=Su8GetCode;
    

  397. P1_0=1;  
    

  398. P1_1=1;  
    

  399. P1_2=0;  
    

  400. P1_3=1;         
    

  401. break;
    


  402. 

  403.        case 4: 
    

  404. Su8GetCode=Cu8DigTable[vGu8Display_Righ_4]; 
    

  405. if(1==vGu8Display_Righ_Dot_4) 
    

  406. {
    

  407. Su8GetCode=Su8GetCode|0x80;  
    

  408. }
    

  409.     P0=Su8GetCode; 
    

  410. P1_0=1;  
    

  411. P1_1=1;  
    

  412. P1_2=1;  
    

  413. P1_3=0;           
    

  414. break;
    


  415. 

  416. }
    


  417. 

  418. Su8ScanStep++;
    

  419. if(Su8ScanStep>4) 
    

  420. {
    

  421. Su8ScanStep=1;
    

  422. }
    


  423. 

  424. vGu8ScanTimerFlag=0; 
    

  425. vGu16ScanTimerCnt=SCAN_TIME;  
    

  426. vGu8ScanTimerFlag=1;  
    

  427. }
    

  428. }
    


  429. 


  430. 

  431. void VoiceScan(void) //蜂鸣器的驱动函数
    

  432. {
    


  433. 

  434.           static unsigned char Su8Lock=0;  
    


  435. 

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

  437.           {
    

  438.                   if(0==Su8Lock)
    

  439.                   {
    

  440.                    Su8Lock=1;  
    

  441. BeepOpen(); 
    

  442.      }
    

  443.     else  
    

  444. {     
    


  445. 

  446.                        vGu16BeepTimerCnt--;         
    


  447. 

  448.                    if(0==vGu16BeepTimerCnt)
    

  449.                    {
    

  450.                            Su8Lock=0;     
    

  451. BeepClose();  
    

  452.                    }
    


  453. 

  454. }
    

  455.           }         
    

  456. }
    


  457. 

  458. void BeepOpen(void)
    

  459. {
    

  460. P3_4=0;  
    

  461. }
    


  462. 

  463. void BeepClose(void)
    

  464. {
    

  465. P3_4=1;  
    

  466. }
    


  467. 

  468. void T0_time() interrupt 1     
    

  469. {
    

  470. VoiceScan();    //蜂鸣器的驱动函数
    

  471. KeyScan();      //按键底层的驱动扫描函数
    

  472. DisplayScan();  //数码管底层的驱动扫描函数
    


  473. 

  474. if(1==vGu8ScanTimerFlag&&vGu16ScanTimerCnt>0)  
    

  475. {
    

  476. vGu16ScanTimerCnt--;  //递减式的软件定时器
    

  477. }
    


  478. 

  479. TH0=0xfc;   
    

  480. TL0=0x66;   
    

  481. }
    


  482. 


  483. 

  484. void SystemInitial(void) 
    

  485. {
    

  486. P0=0x00;
    

  487. P1_0=1;  
    

  488. P1_1=1;  
    

  489. P1_2=1;  
    

  490. P1_3=1;  
    


  491. 

  492. TMOD=0x01;  
    

  493. TH0=0xfc;   
    

  494. TL0=0x66;   
    

  495. EA=1;       
    

  496. ET0=1;      
    

  497. TR0=1;      
    

  498. }
    


  499. 

  500. void Delay(unsigned long u32DelayTime) 
    

  501. {
    

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

  503. }
    


  504. 

  505. void PeripheralInitial(void) 
    

  506. {
    


  507. 

  508. }


本帖子中包含更多资源

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

×
回复

收藏269 举报

tanik 发表于 2018-5-13 21:46 | 显示全部楼层
走到哪里，都要顶！
回复

收藏269 举报

波哥有气质 发表于 2018-5-15 16:09 | 显示全部楼层
jianhong_wu 发表于 2017-10-2 11:54
第八十九节： 跑马灯的三种境界。

【89.1   跑马灯的三种境界。】

学到了很多，感谢您的无私奉献！！
回复

收藏269 举报

zxf6641 发表于 2018-5-21 20:27 来自手机 | 显示全部楼层
感谢楼主无私奉献科普知识，国家需要的就是这踏实做事的人才！
回复

收藏269 举报

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

本版积分规则

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