设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 基于51单片机四位一体数码管显示定时器控制短按加或减数 ...
返回列表 发新帖
查看: 2085|回复: 1
收起左侧

基于51单片机四位一体数码管显示定时器控制短按加或减数值及长按连加或连减数值的...

[复制链接]
ID:171036 发表于 2020-5-20 14:55 | 显示全部楼层 |阅读模式
本帖最后由 51黑电子会员 于 2020-5-26 22:08 编辑
  1. #include<reg51.h>
  2. #define uchar unsigned char
  3. #define uint unsigned int
  4. sbit add=P3^0;
  5. sbit dec=P3^4;
  6. uchar lingweiflag;//显示0标志位变量
  7. uchar code weima[]={0xfe,0xfd,0xfb,0xf7};//数码管位码表
  8. uchar code table[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f} ; //共阴数码管段码数字0~9字码表，高电平点亮数码管段码数字0~9。
  9. uint num;
  10. uint count;
  11. uint qian,bai,shi,ge;//定义拆字变量
  12. ///**ms级延时子程序**/
  13. //  void delay(uint x)
  14. //{
  15. //   uint i,j;                       
  16. //   for(i=0;i<x;i++)     
  17. //    for(j=0;j<110;j++);
  18. //  }
  19. ///**定时器ms级延时子程序**/
  20. //  void time0_delay(uchar time)//注意这里不是普通延时，而是定时器延时函数。
  21. //{
  22. //   TR0=1;
  23. //   count = 0;//需要定时器延时count，先清零，再循环检测是否计到count，是则退出。
  24. //   while(1)
  25. // {
  26. //    if(count>=time)
  27. //  {     
  28. //     break;
  29. //   }
  30. //  }  
  31. // }
  32. //  void display()
  33. //{
  34. //   qian=num/1000;//取得千位
  35. //   bai=num%1000/100;//取得百位
  36. //   shi=num%100/10;//取得十位数字
  37. //   ge=num%10;//取得个位数字
  38. //
  39. //   P2=0xfe;//数码管千位显示位
  40. //   P1=table[qian];//数码管千位数值显示
  41. //   delay(2);//延时
  42. //
  43. //   P2=0xfd;//数码管百位显示位
  44. //   P1=table[bai];//数码管百位数值显示
  45. //   delay(2);//延时
  46. //
  47. //   P2=0xfb;//数码管十位显示位
  48. //   P1=table[shi];//数码管十位数值显示
  49. //   delay(2);//延时
  50. //
  51. //   P2=0xf7;//数码管个位显示位
  52. //   P1=table[ge];//数码管个位数值显示
  53. //   delay(2);//延时
  54. // }
  55.   void display()//显示程序
  56. {
  57.    static uchar i;
  58.    P1=0x00;
  59.    P2=0xff;
  60.    switch(i)
  61. {
  62.     case 0:
  63.            P2=weima[i];
  64.            P1=table[num/1000];
  65.            i++;
  66.            break;
  67.     case 1:
  68.            P2=weima[i];
  69.            P1=table[num%1000/100];
  70.            i++;
  71.            break;
  72.     case 2:
  73.            P2=weima[i];
  74.            P1=table[num%100/10];
  75.            i++;
  76.            break;
  77.     case 3:
  78.            P2=weima[i];
  79.            P1=table[num%10];
  80.            i++;
  81.            break;
  82.     default : break;//自定义
  83.    }
  84.    if(i>3)
  85.    i=0;
  86. }
  87.   void keyscan()
  88. {         
  89.    while(!add)//增加键短按长按。为什么只用while(!add)？while(!add)它又表示什么？解释：当你的按键一直没有释放，即add=0，那么while(!add)中的!add就为1，表示为真，可以执行while(!add)语句所在花括号内的程序。当你松开按键，即add=1,那么 while(!add)中的!add为0，表示为假，不可执行while(!add)语句所在花括号内的程序。
  90. {   
  91.     if(count>=100)
  92.   {
  93.      num++;
  94.      count=0;
  95.      lingweiflag=0;
  96.     }
  97.    }
  98.    while(!dec)//减少键短按长按。为什么只用while(!dec)？while(!dec)它又表示什么？解释：当你的按键一直没有释放，即dec=0，那么while(!dec)中的!dec就为1，表示为真，可以执行while(!dec)语句所在花括号内的程序。当你松开按键，即dec=1,那么 while(!dec)中的!dec为0，表示为假，不可执行while(!dec)语句所在花括号内的程序。
  99. {   
  100.     if(lingweiflag==0)
  101.   {
  102.      if(count>=100)
  103.    {
  104.       num--;
  105.       count=0;
  106.       if(num==0)
  107.     {
  108.        num=0;
  109.        lingweiflag=1;
  110.       }
  111.      }
  112.     }
  113.    }
  114. //   if(add==0)//增加长按
  115. // {         
  116. //    TR0=1;
  117. //    if(count==100)
  118. //  {
  119. //     num++;
  120. //     count=0;
  121. //     lingweiflag=0;
  122. //    }
  123. //   }
  124. //   if(add==0)//增加短按
  125. // {         
  126. //    TR0=1;
  127. //      time0_delay(20);//注意这里不是普通延时，而是定时器延时。
  128. //    display();
  129. //    if(add==0)
  130. //  {
  131. //       time0_delay(20);//注意这里不是普通延时，而是定时器延时。
  132. //       while(!add)
  133. //       display();
  134. //     led=0;
  135. //       while(!add);
  136. //       led=1;
  137. //       num++;  
  138. //       count=0;
  139. //       lingweiflag=0;
  140. //    }
  141. //   }
  142. //   else if(dec==0&&lingweiflag==0)//减少长按
  143. // {
  144. //      TR0=1;
  145. //      if(count==100)
  146. //  {
  147. //       num--;
  148. //       count=0;
  149. //    }
  150. //   }
  151. //   if(dec==0&&lingweiflag==0)//减少短按
  152. // {         
  153. //    TR0=1;
  154. //      time0_delay(20);//注意这里不是普通延时，而是定时器延时。
  155. //    display();
  156. //    if(dec==0)
  157. //  {
  158. //       time0_delay(20);//注意这里不是普通延时，而是定时器延时。
  159. //       while(!dec)
  160. //       display();
  161. //       num--;
  162. //       count=0;
  163. //    }
  164. //   }
  165.    if(num>9999)
  166. {
  167.     num=0;
  168.    }
  169.    if(num==0)
  170. {
  171.     num=0;
  172.     lingweiflag=1;
  173.    }
  174. }
  175.   void Time0_init()
  176. {
  177.    TMOD=0x01;
  178.    TH0=(65536-2000)/256;
  179.    TL0=(65536-2000)%256;
  180.    EA=1;
  181.    ET0=1;
  182.    TR0=1;
  183.   }
  184.   void time0() interrupt 1
  185. {
  186.    TH0=(65536-2000)/256;
  187.    TL0=(65536-2000)%256;
  188.    count++;
  189.    display();
  190. }
  191.   void main()
  192. {
  193.    Time0_init();
  194.    while(1)
  195. {
  196.     keyscan();
  197.    }
  198.   }



  202. //按键短按加或减，长按连加或连减，四位一体数码管显示0~9999。
  203. //#include<reg52.h>
  204. //#define uchar unsigned char
  205. //#define uint unsigned int
  206. //#define key_short 10//宏定义短按20ms
  207. //#define key_long 50//宏定义长按100ms
  208. //#define key_middle 40//宏定义长按间隔80ms
  209. //sbit led=P1^4;//启停指示灯
  210. //sbit addkey=P3^0;//位定义加键
  211. //sbit deckey=P3^2;//位定义减键
  212. //sbit qiting=P3^4;//位定义启动按键端口
  213. //sbit tingzhi=P3^6;//位定义停止按键端口
  214. ////uchar i;//数码管位数变量
  215. //uchar flag;//显示函数标志位变量
  216. //uchar qitingnum;//声明启停次数变量
  217. //uint num;//数值变量
  218. //uint addcount,deccount;//计数变量
  219. //uint qian,bai,shi,ge;//定义拆字变量
  220. ////uchar code weima[]={0xfe,0xfd,0xfb,0xf7};//数码管位码表
  221. //uchar code table[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f} ; //共阴数码管段码数字0~9字码表，高电平点亮数码管段码数字0~9。
  222. ///**ms级延时子程序**/
  223. //  void delay(uint x)
  224. //{
  225. //   uint i,j;                       
  226. //   for(i=0;i<x;i++)     
  227. //    for(j=0;j<110;j++);
  228. //  }
  229. //  void display()
  230. //{
  231. //   qian=num/1000;//转速/10000的余数/1000得到千位
  232. //   bai=num%1000/100;//取得百位
  233. //   shi=num%100/10;//取得十位数字
  234. //   ge=num%10;//取得个位数字
  235. //
  236. //   P2=0xfe;//数码管千位显示位
  237. //   P0=table[qian];//数码管千位数值显示
  238. //   delay(2);//延时
  239. //
  240. //   P2=0xfd;//数码管百位显示位
  241. //   P0=table[bai];//数码管百位数值显示
  242. //   delay(2);//延时
  243. //
  244. //   P2=0xfb;//数码管十位显示位
  245. //   P0=table[shi];//数码管十位数值显示
  246. //   delay(2);//延时
  247. //
  248. //   P2=0xf7;//数码管个位显示位
  249. //   P0=table[ge];//数码管个位数值显示
  250. //   delay(2);//延时
  251. //}
  252. //  void qidongkeyscan()//启动函数
  253. //{
  254. //   if(qiting==0)
  255. // {
  256. //    delay(15);
  257. //    if(qiting==0)
  258. //  {
  259. //     qitingnum++;
  260. //     TR0=1;
  261. //     flag=0;
  262. //     while(qiting==1);
  263. //    }
  264. //   }
  265. // }
  266. //  void tingzhikeyscan()//关掉函数
  267. //{
  268. //   if(tingzhi==0)
  269. // {
  270. //    delay(15);
  271. //    if(tingzhi==0)
  272. //  {
  273. //     led=1;
  274. //     flag=1;
  275. //     TR0=0;
  276. //     P2=0xff;
  277. //     P0=0x00;
  278. //     qitingnum=0;
  279. //     while(tingzhi==1);
  280. //    }
  281. //   }
  282. // }
  283. //  void keyscan()//设置函数
  284. //{
  285. //   if(qitingnum==1)
  286. // {
  287. //    led=0;
  288. //    if(!addkey)
  289. //  {
  290. //     addcount++;
  291. ////   delay(10);
  292. //     if(addcount>=key_long)//增加长按
  293. //   {
  294. //      if(num<9999)
  295. //      num++;        
  296. //      addcount=key_middle;//为什么存在addcount=key_middle，由于一直按着按键，addcount计数会溢出，设定addcount=key_middle能让addcount在这个addcount=key_middle基础上反复累积计数，从而不会出现计数溢出的情况。
  297. //     }
  298. //    }
  299. //     else
  300. //   {
  301. //      if(key_short<addcount&&addcount<key_long)//增加短按，为什么不可以是key_short<addcount<key_long，假若是key_short<addcount<key_long，就相当于按键还没按下，条件已经满足，按键再按下去就没意义啦。
  302. //    {
  303. //       if(num<9999)
  304. //       num++;        
  305. //      }
  306. //      addcount=0;
  307. //    }
  308. //    if(!deckey)
  309. //  {
  310. //     deccount++;
  311. ////   delay(10);
  312. //     if(deccount>=key_long)//减少长按
  313. //   {
  314. //      if(num>0)
  315. //      num--;        
  316. //      deccount=key_middle;//为什么存在deccount=key_middle，由于一直按着按键，deccount计数会溢出，设定deccount=key_middle能让addcount在这个deccount=key_middle基础上反复累积计数，从而不会出现计数溢出的情况。
  317. //     }
  318. //    }
  319. //     else
  320. //   {
  321. //      if(key_short<deccount&&deccount<key_long)//减少短按，为什么if条件不可以是key_short<deccount<key_long，假若是key_short<deccount<key_long，就相当于按键还没按下，条件已经满足，按键再按下去就没意义啦。
  322. //    {
  323. //       if(num>0)
  324. //       num--;        
  325. //      }
  326. //      deccount=0;
  327. //    }
  328. //   }
  329. //  }
  330. ////  void display()//显示程序
  331. ////{
  332. ////// static uchar i;
  333. ////   P0=0x00;
  334. ////   P2=weima[i];
  335. ////   switch(i)
  336. //// {
  337. ////    case 0:
  338. ////           P0=table[num/1000];
  339. ////           break;
  340. ////    case 1:
  341. ////           P0=table[num%1000/100];
  342. ////           break;
  343. ////    case 2:
  344. ////           P0=table[num%100/10];
  345. ////           break;
  346. ////    case 3:
  347. ////           P0=table[num%10];
  348. ////           break;
  349. ////  }
  350. ////   i++;
  351. ////   i%=4;
  352. //// }
  353. //  /**定时器0初始化子程序**/
  354. //  void Time0_init()
  355. //{
  356. //   TMOD=0X01;//模式选定时器0、计数器1，工作方式选定时器0定时模式1、计数器1计数模式1。
  357. //   TH0=(65536-5000)/256;//定时器0高8位定时50毫秒
  358. //   TL0=(65536-5000)%256;//定时器0低8位定时50毫秒
  359. //   EA=1;//打开总中断
  360. //   ET0=1;//打开定时器0的中断
  361. //   TR0=0;//打开定时器0
  362. //  }
  363. //  void Timer0() interrupt 1//定时器0中断子程序
  364. //{
  365. //   TH0=(65536-5000)/256;//重装定时器0高8位定时50毫秒
  366. //   TL0=(65536-5000)%256;//重装定时器0低8位定时50毫秒
  367. //   keyscan();//设置函数
  368. //   if(flag==0)
  369. //   display();//显示函数
  370. //   tingzhikeyscan();//关掉函数
  371. //  }
  372. //  void main()//主函数
  373. //{
  374. //   Time0_init();//定时器0初始化子程序
  375. //   while(1)
  376. // {
  377. //    qidongkeyscan();//启动函数
  378. //  }
  379. // }
复制代码
图片101.png

评分

参与人数 1黑币 +40 收起 理由
admin + 40 共享资料的黑币奖励！

查看全部评分

回复

使用道具 举报

ID:293762 发表于 2020-5-23 08:10 | 显示全部楼层
好好学习，感谢分享！
回复

使用道具 举报

ID:171036 发表于 2020-5-23 12:22 | 显示全部楼层
本帖最后由 51黑电子会员 于 2020-5-26 22:10 编辑
守候枫林红叶时 发表于 2020-5-23 08:10
好好学习，感谢分享！

谢谢 小伙伴
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表