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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 单片机为核心的8位竞赛抢答器仿真和源程序 倒计时剩余时 ...
返回列表 发新帖
查看: 3252|回复: 1
打印 上一主题 下一主题
收起左侧

单片机为核心的8位竞赛抢答器仿真和源程序 倒计时剩余时间还未完成

[复制链接]
跳转到指定楼层
楼主
ID:362588 发表于 2018-7-1 16:49 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
1） 抢答器同时供8名选手或8个代表队比赛，分别用8个按钮s1-s8表示；
2） 设置一个系统清除和抢答控制开关Key1和Key2。
3） 抢答器具有锁存与显示功能。即选手按下按钮，锁存相应编号，显示该选手编号至数码管，并且该编号保存至主持人按下清除键Key1清除为止。
4） 抢答器具有定时抢答功能，一次抢答设定的时间为30秒。主持人按下抢答控制开关Key2，抢答才能开始，启动定时器，并将倒数计时时间用数码管显示。若定时时间到，无人抢答，则该轮抢答结束，系统通过蜂鸣器报警，选手禁止抢答。
5） 选手在设定的时间内进行抢答，抢答有效，定时器停止工作，蜂鸣器报警，数码管显示选手编号及倒计时剩余时间，并保持到主持人将系统清除为止。
仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）


单片机源程序如下:
  1. #include <reg52.h>

  3. //共阴极数码管编码表 0 - f显示
  4. unsigned char code table[]={0x3f,0x06,0x5b,0x4f,0x66,
  5. 0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,
  6. 0x39,0x5e,0x79,0x71};

  8. //变量定义
  9. sbit start_stop = P3^6;
  10. sbit reset = P3^7;
  11. sbit LE =P3^0;
  12. sbit key1 = P1^0;
  13. sbit key2 = P1^1;
  14. sbit key3 = P1^2;
  15. sbit key4 = P1^3;
  16. sbit key5 = P1^4;
  17. sbit key6 = P1^5;
  18. sbit key7 = P1^6;
  19. sbit key8 = P1^7;
  20. sbit state = P3^4;
  21. sbit start=P3^1;

  23. bit start_stop_flag = 0;
  24. bit key1_flag = 0;
  25. bit key2_flag = 0;
  26. bit key3_flag = 0;
  27. bit key4_flag = 0;
  28. bit key5_flag = 0;
  29. bit key6_flag = 0;
  30. bit key7_flag = 0;
  31. bit key8_flag = 0;
  32. bit reset_flag = 0;
  33. bit action = 0;
  34. bit start_flag=0;

  36. unsigned char second = 15;
  37. unsigned char timer0_count = 0;
  38. unsigned char number = 0;
  39. unsigned char number_display = 0;

  41. //延时函数
  42. void delay(unsigned int z)
  43. {
  44.         unsigned int x,y;
  45.         for(x=z;x>0;x--)
  46.                 for(y=110;y>0;y--);
  47. }

  49. void Play(unsigned char t)
  50. {
  51.     unsigned char i;
  52.     for(i=0;i<100;i++)
  53.    {
  54.     state=~state;
  55.         delay(t);
  56.         }
  57.         state=0;
  58. }

  60. //数码管显示驱动函数
  61. void display(unsigned char number,unsigned char second)
  62. {
  63.         unsigned char second_first,second_second;
  64.         second_first = second / 10;
  65.         second_second = second % 10;
  66.         
  67.         P2 = 0xfe;
  68.         P0 = table[number];
  69.         delay(1);
  70.         
  71.         P2 = 0xfb;
  72.         P0 = table[second_first];
  73.         delay(1);
  74.         
  75.         P2 = 0xf7;
  76.         P0 = table[second_second];
  77.         delay(1);        
  78. }

  80. //开始键扫描函数
  81. void start_stop_keyscan()
  82. {
  83.         if(start_stop == 0)
  84.         {
  85.                 delay(8);
  86.                 if((start_stop == 0)&&(!start_stop_flag))
  87.                 {
  88.                         start_stop_flag = 1;
  89.                         action  = 1;
  90.                         TR0 = 1;
  91.                         //state =0;
  92.                         Play(1);
  93.                 }
  94.         }
  95.         else
  96.         {
  97.                 start_stop_flag = 0;        
  98.         }        
  99. }

  101. //八位抢答键扫描函数
  102. unsigned char key_scan8()
  103. {
  104.         if(key1 == 0)
  105.         {
  106.                 delay(8);
  107.                 if((key1 == 0)&&(!key1_flag))
  108.                 {
  109.                         key1_flag = 1;
  110.                         number  = 1;
  111.                         number_display = number;
  112.                         Play(2);
  113.                         LE=0;
  114.                 }
  115.         }
  116.         else
  117.         {
  118.                 key1_flag = 0;
  119.                 number  = 0;        
  120.         }
  121.         
  122.         if(key2 == 0)
  123.         {
  124.                 delay(8);
  125.                 if((key2 == 0)&&(!key2_flag))
  126.                 {
  127.                         key2_flag = 1;
  128.                         number  = 2;
  129.                         number_display = number;
  130.                         Play(2);
  131.                         LE=0;
  132.                 }
  133.         }
  134.         else
  135.         {
  136.                 key2_flag = 0;
  137.                 number  = 0;        
  138.         }
  139.         
  140.         if(key3 == 0)
  141.         {
  142.                 delay(8);
  143.                 if((key3 == 0)&&(!key3_flag))
  144.                 {
  145.                         key3_flag = 1;
  146.                         number  = 3;
  147.                         number_display = number;
  148.                         Play(2);
  149.                         LE=0;
  150.                 }
  151.         }
  152.         else
  153.         {
  154.                 key3_flag = 0;
  155.                 number  = 0;        
  156.         }
  157.         
  158.         if(key4 == 0)
  159.         {
  160.                 delay(8);
  161.                 if((key4 == 0)&&(!key4_flag))
  162.                 {
  163.                         key4_flag = 1;
  164.                         number  = 4;
  165.                         number_display = number;
  166.                         Play(2);
  167.                         LE=0;
  168.                 }
  169.         }
  170.         else
  171.         {
  172.                 key4_flag = 0;
  173.                 number  = 0;        
  174.         }
  175.         
  176.         if(key5 == 0)
  177.         {
  178.                 delay(8);
  179.                 if((key5 == 0)&&(!key5_flag))
  180.                 {
  181.                         key5_flag = 1;
  182.                         number  = 5;
  183.                         number_display = number;
  184.                         Play(2);
  185.                         LE=0;
  186.                 }
  187.         }
  188.         else
  189.         {
  190.                 key5_flag = 0;
  191.                 number  = 0;        
  192.         }
  193.         
  194.         if(key6 == 0)
  195.         {
  196.                 delay(8);
  197.                 if((key6 == 0)&&(!key6_flag))
  198.                 {
  199.                         key6_flag = 1;
  200.                         number  = 6;
  201.                         number_display = number;
  202.                         Play(2);
  203.                         LE=0;
  204.                 }
  205.         }
  206.         else
  207.         {
  208.                 key6_flag = 0;
  209.                 number  = 0;        
  210.         }
  211.         
  212.         if(key7 == 0)
  213.         {
  214.                 delay(8);
  215.                 if((key7 == 0)&&(!key7_flag))
  216.                 {
  217.                         key7_flag = 1;
  218.                         number  = 7;
  219.                         number_display = number;
  220.                         Play(2);
  221.                         LE=0;
  222.                 }
  223.         }
  224.         else
  225.         {
  226.                 key7_flag = 0;
  227.                 number  = 0;        
  228.         }
  229.         
  230.         if(key8 == 0)
  231.         {
  232.                 delay(8);
  233.                 if((key8 == 0)&&(!key8_flag))
  234.                 {
  235.                         key8_flag = 1;
  236.                         number  = 8;
  237.                         number_display = number;
  238.                         Play(2);
  239.                         LE=0;
  240.                 }
  241.         }
  242.         else
  243.         {
  244.                 key8_flag = 0;
  245.                 number  = 0;        
  246.         }
  247.                                                         
  248.         if(number_display != 0)        
  249.         {
  250.                 return 1;
  251.         }
  252.         else
  253.         {
  254.                 return 0;
  255.         }        
  256.         
  257. }

  259. //复位键扫描函数
  260. void reset_keyscan()
  261. {
  262.         if(reset == 0)
  263.         {
  264.                 delay(8);
  265.                 if((reset == 0)&&(!reset_flag))
  266.                 {        second=15;
  267.                         reset_flag = 1;
  268.                         number_display = 0;
  269.                         LE = 1;
  270.                         //state = 1;
  271.                 }
  272.         }
  273.         else
  274.         {
  275.                 reset_flag = 0;
  276.         }        
  277. }
  278.          

  280. //主函数

  282. void main()
  283. {
  284.         TMOD=0x01;
  285.     TH0=0x3C;
  286.         TL0=0xB0;
  287.         EA=1;
  288.         ET0=1;
  289.         TR0=0;
  290.         
  291.         while(1)
  292.         {        while((start == 0)&&(!start_flag))
  293.          {        start_stop_keyscan();
  294.                 reset_keyscan();
  295.                 while(action)
  296.                 {
  297.                         while(!key_scan8())
  298.                         {
  299.                                 display(number_display,second);
  300.                                 if(second == 0)
  301.                                 {
  302. ……………………

  304. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
抢答.rar (67.64 KB, 下载次数: 67)



分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏2 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:365098 发表于 2018-7-5 09:24 | 只看该作者
兄弟倒计时剩余时间显示不出来啊？
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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