找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 2319|回复: 2
打印 上一主题 下一主题
收起左侧

单片机实现八路抢答器+查看分数+加减分源程序

[复制链接]
跳转到指定楼层
楼主
ID:752027 发表于 2020-5-14 20:25 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
基于单片机的八路抢答器
一、主要内容
通过利用数码管显示,并自动复位的思路,运用单片机的运行产生输出信号,通过数码管显示对应的通道,实现了一个以单片机为核心的8路抢答器,
并且具有查看选手分数和进行加减分的功能。

二、具体操作
2、主持人按下开始键选手等待时间计完听到滴声后才可以抢答,若提前抢到则
视为犯规。
3、抢答成功后别的选手再抢到也是没有用的。
4、显示屏上显示哪位选手抢到,并开始对答题时间进行倒计时。
5、显示答题时间,在答题时间小于 5S 时报警电路会发生作用。
7、当主持人按下 RESET 键则进行下一轮的比赛。

二、程序用什么软件查看?   

打开程序的软件是Keil

单片机源程序如下:
  1. #include <reg51.h>
  2. #include <intrins.h>
  3. #define uint unsigned int
  4. #define uchar unsigned char
  5. sbit smg1=P2^0;                //定义数码管第一位
  6. sbit smg3=P2^2;                //定义数码管第三位
  7. sbit smg4=P2^3;                //定义数码管第四位
  8. sbit keyks=P3^5;               //定义开始按键
  9. sbit keytz=P3^4;               //定义停止按键
  10. sbit keyqc=P3^3;               //定义清除按键

  11. sbit beep=P3^6;                //定义蜂鸣器
  12. uchar k;
  13. uchar keyvalue=0;
  14. uint a;
  15. int djs=20,js=0;                   //djs和bt是初始倒计时时间,可修改
  16. int table[] = {0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};
  17. int zhunbei[] = {0x92,0x99,0xb0,0xa4,0xf9,0xc0};//准备抢答
  18. int fenshu[] = {0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};
  19. char fs[8];

  20. uchar mode=0;              //主持人的按键模式
  21. //  mode=0:显示选手1的分数  mode=1:显示选手2的分数....../////////



  22. void delayzb(uint z)//准备抢答延时
  23. {
  24.          uint x,y;//局部变量定义
  25.          for(x = z;x>0;x--)//此for循环100次
  26.          for(y = 144;y>0;y--);//此for循环144次,100*144次循环正好是100ms.
  27. }

  28. void delay()
  29. {
  30.         uchar m,n,s;
  31.         for(m = 20;m>0;m--);
  32.         for(n = 20;n>0;n--);
  33.         for(s = 248;s>0;s--);
  34. }


  35. void delayms(uint z)
  36. {
  37.                 uint x,y;
  38.                 for(x=z;x>0;x--)
  39.                 for(y=110;y>0;y--);
  40. }



  41. void Getch ()        //取键值函数
  42. {
  43.         //keyvalue=0;
  44.    P1=0xf0; //先对P3 置数 列扫描
  45.   if(P1!=0xf0) //判断是否有键按下
  46.   {
  47.           delay(); //延时,软件去干扰
  48.            if(P1!=0xf0) //确认按键按下
  49.           {
  50.                         switch (P1) //判断键值(哪一列被按下)
  51.                         {                                
  52.                                         case 0xe0: keyvalue=1; break; //第一列被按下
  53.                                         case 0xd0: keyvalue=2; break; //第二列被按下
  54.                                         case 0xb0: keyvalue=3; break; //被三列被按下
  55.           case 0x70: keyvalue=4; break; //被四列被按下
  56.                         }
  57.                         P1 = 0x0f;   //行扫描
  58.                         switch (P1)  //判断哪一行被按下
  59.                         {
  60.                                         case 0x0e: keyvalue=keyvalue; break; //第一行被按下
  61.                                         case 0x0d: keyvalue=keyvalue + 4; break; //第二行被按下
  62.                                         case 0x0b: keyvalue=keyvalue + 8; break; //第三行被按下
  63.                                   case 0x07: keyvalue=keyvalue + 12; break; //第四行被按下
  64.                         }   
  65.                         while (P1 != 0x0f);  //松手检测
  66.                  }
  67.          }
  68. }



  69. void Timer0_init()                        //定时器0初始化
  70. {
  71.                 js=0;
  72.                 TMOD=0x01;                   //TR0=1;//IT1=1;   //T0为定时器方式1   //EX1=1;
  73.                 TH0=0x4c;             //每50ms溢出一次
  74.                 TL0=0x00;                        
  75.                 ET0=1;
  76.                 EA=1;        
  77. }


  78. void timer0() interrupt 1 using 1        //定时器0中断服务函数
  79. {
  80.         TF0=0;
  81.         TH0=0x4c;                                        //每50ms溢出一次
  82.         TL0=0x00;                                        //赋初值
  83.         js++;
  84.          if(js==20)                                      //20*50=1000ms=1s
  85.         {
  86.                 js=0;
  87.                 djs--;                                        //产生1s的倒计时
  88.   }
  89.         if(djs==5)
  90.         {
  91.                 beep = 0;                          //倒计时后5s报警
  92.                 delay();
  93.                 beep = 1;
  94.                 delay();
  95.         }
  96.   if(djs==0)
  97.         {        
  98.                 P2 = 0xff;
  99.                 TR0=0;                            //倒计时结束,关闭定时器

  100.   }
  101. }








  102. void djsxs()                                   //显示倒计时函数
  103. {        
  104.                 int shi,ge;
  105.                 shi=djs/10;
  106.                 ge=djs%10;                                  // 将倒计时时间分成高低位

  107.                 P2=0XFF;         
  108.                 smg4 = 0;
  109.                 P0=table[ge];
  110.                 smg4 = 0;
  111.                 delayms(2);
  112.                 P2=0XFF;


  113.                 smg3 = 0;
  114.                 P0=table[shi];
  115.                 smg3 = 0;
  116.                 delayms(2);
  117.                 P2=0XFF;
  118. }


  119. void djsxs22()   //显示- --                              
  120. {
  121.                 P2=0XFF;
  122.                 P0=0xbf;
  123.                 smg1 = 0;
  124.                 delayms(3);
  125.                 P2=0XFF;                                        //第一位数码管显示-

  126.                 P0=0xbf;
  127.                 smg3 = 0;
  128.                 delayms(3);                           //第三位数码管显示-
  129.                 P2=0XFF;

  130.                 P0=0xbf;
  131.                 smg4 = 0;
  132.                 delayms(3);
  133.                 P2=0XFF;                                //第四位数码管显示-
  134. }





  135. void playerxs()
  136. {
  137.     P0=table[keyvalue];
  138.     smg1=0;
  139.     delayms(3);
  140.     smg1=1;
  141. }        //第一位数码管显示





  142. void main()
  143. {
  144.                 int djs1=20;              
  145.                 Timer0_init();         //初始化定时器中断
  146.                 beep=1;                //蜂鸣器不响
  147.                 djs=20;                     //倒计时赋值

  148.         
  149.          while(1)
  150.         {
  151.                 LOOP1:
  152.     Getch();               
  153.                 djs=djs1;
  154.                 djsxs22();        //LOOP1是标号,显示 -  --
  155.                 keyvalue = 0;
  156. //                beep=1;                //蜂鸣器不响
  157.                 djs=20;                     //倒计时赋值
  158.                 TR0 = 0;
  159.                
  160.                
  161.                  if(keyks==0)//开始按键
  162.            {
  163.                          beep=0;//蜂鸣器响
  164.                          delayms(3);          //去除按键抖动
  165.                      if(keyks==0)   //确定开始按下
  166.                          {         
  167.                                  
  168.                                          while(!keyks);       //松手检测        
  169.                                         {
  170.                                                 beep=1;
  171.                                                 for(a = 0;a<6;a++) //5s倒计时准备抢答
  172.                                                 {
  173.                                                         P2 = 0xf7;//1111 0111       //第四位数码管显示5s倒计时
  174.                                                         P0 = zhunbei[a];
  175.                                                         delayzb(800);
  176.                                                         P2 = 0xff;
  177.                                                 }
  178.                                         }
  179.                                        
  180.                                          while(1)
  181.                                   {
  182.                                                            Getch();
  183.                                                 
  184.                                                if(keyqc == 0)
  185.                                                            {
  186.                                                                          delayms(3);                   //去除抖动
  187.                                            if(keyqc == 0)
  188.                                                                         {
  189.                                                                                  while(!keyqc); //如果按下清除键,则回到- --状态
  190.                                                                                  goto LOOP1;                  //goto语句,回到loop1表号处
  191.                                                                         }
  192.                                                           }
  193.                                                                  

  194.                                                                           
  195.                                                          
  196.                                 /*以下是八个选手抢答,key1表示1号选手,依次类推,注释只写第一位选手,其他和第一个完全一致*/

  197.                                                                        
  198.                                                                  if((keyvalue>=1)&&(keyvalue<=8)&&(TR0==0))        //在定时器关闭状态下,key1==0 则说明1号选手按下按
  199.                                                                 {
  200.                                                                          beep=0;                 //蜂鸣器响
  201.                                          
  202.                                                                                         //while(!key1);          //去除按键抖动后,重新在判断,是否确实按下
  203.                                                                                         beep=1;                  //蜂鸣器不响
  204.                                                                                         TR0=1;                   //定时器开始
  205.                                                                                         while(1)
  206.                                                                                         {
  207.                                                                                                 mode = keyvalue;
  208.                                                                                                 playerxs();            //显示选手编号
  209.                                                                                                 djsxs();                //显示剩余倒计时时间
  210.                                                                                                 //keyvalue = 1;
  211.                                                                                                 
  212.                                                                                                  if(keyqc == 0)
  213.                                                                                                  {         
  214.                                                                                                          delayms(3);                   //去除抖动
  215.                                                                                                          if(keyqc == 0)
  216.                                                                                                                 {
  217.                                                                                                                          while(!keyqc); //如果按下清除键,则回到- --状态
  218.                                                                                                                          goto LOOP1;                  //goto语句,回到loop1表号处
  219.                                                                                                                 }
  220.                                                                                                  }
  221.                                                                                                         if(keytz == 0)          //暂停按下按下
  222.                                                                                                         {        
  223.                                                                                                                  delayms(3);                   //去除抖动
  224.                                                                                                                  if(keytz == 0)           //再次判断是否按下复位按键
  225.                                                                                                                  {
  226.                                                                                                                                 while(!keytz) //如果按下复位键,则回到- --状态
  227.                                                                                                                                 TR0=0;                                       
  228.                                                                                                                         }
  229.                                                                                                          }                                                                                 
  230.                                                                                                         if(keyks == 0)//开始按键
  231.                                                                                                         {
  232.                                                                                                                                                                                  
  233.                                                                                                                   beep=0;//蜂鸣器响
  234.                                                                                                                  delayms(30);          //去除按键抖动
  235.                                                                                                                  if(keyks == 0)   //确定开始按下
  236.                                                                                                                  {
  237.                                                                                                                         while(!keyks);       //松手检测
  238.                                                                                                                  {
  239.                                                                                                                                 beep=1;                                                                                                                         //蜂鸣器不响
  240.                                 delay();
  241.                                                                                                                                                 
  242.                                                                                                                                 TR0 = 1;                                                
  243.                                                                                                                   }        
  244.                                                                                                                  }
  245.                                                                                                          }
  246.                                                                                                         if(djs == 0)
  247.                                                                                                         
  248.                                                                                                          break;
  249.                                                                                                         
  250.                                                                                                  }
  251.                                                                                         }                                                                                       
  252.                                                                         
  253.                                                         if (mode!=0)
  254.                                                         {
  255.                                               TR0 = 0;
  256.                                                                                 
  257.                                                                                 while(1)
  258.                                                                                 {
  259.                                                                                                 P0=table[mode];
  260.                                                                                                 smg1=0;
  261.                                                                                                 delayms(3);
  262.                                                                                                 smg1=1;              //显示选手编号                                                                                
  263.                                                                                     P0=table[fs[mode]];
  264.                                                                                     smg4=0;
  265.                         delayms(3);
  266.                                                                                     smg4=1;

  267.                                                                                                 Getch();
  268.                                                                                                 if(keyvalue == 9)
  269.                                                                                                 {
  270.                                                                                                         keyvalue = 0;
  271.                                                                                                                  mode++;
  272.                                                                                                                 if(mode>8)
  273.                                                                                                                 {
  274.                                                                                                                         mode=0;
  275.                                                                                                                 }                                                        
  276.                                                                                                 }
  277.                                                                                                 else if(keyvalue == 10)   //加分
  278.                                                                                                 {
  279.                           keyvalue = 0;
  280.                                                                                                         fs[mode]++;
  281.                                                                                                         if(fs[mode] == 10)
  282.                                                                                                         fs[mode] = 9;                                                
  283.                                                                                                 }
复制代码

八路抢答器last.zip

32.09 KB, 下载次数: 35, 下载积分: 黑币 -5

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

使用道具 举报

沙发
ID:779675 发表于 2020-6-15 17:12 | 只看该作者
那个能把原理图发一下吗
回复

使用道具 举报

板凳
ID:785533 发表于 2020-6-21 08:54 | 只看该作者
程序不对吧
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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