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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 关于抢答器,请大佬帮忙看看我截图的那几行单片机代码是 ...
返回列表 发新帖
查看: 1283|回复: 1
打印 上一主题 下一主题
收起左侧

关于抢答器,请大佬帮忙看看我截图的那几行单片机代码是什么意思?

[复制链接]
跳转到指定楼层
楼主
ID:857089 发表于 2020-12-10 08:22 来自手机 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式


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

  3. #define JZKEY P1

  5. #define GPIO_DIG P0

  7. sbit LSA=P2^2;
  8. sbit LSB=P2^3;
  9. sbit LSC=P2^4;

  11. sbit K1=P3^2;
  12. sbit K2=P3^3;

  14. sbit BEEP=P1^5;

  16. sbit LED1=P2^7;
  17. sbit LED2=P2^6;
  18. sbit LED3=P2^5;
  19. sbit LED4=P2^1;
  20. sbit LED5=P2^0;

  22. unsigned char code COMD_CODE[17] = {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71,0x00};
  23. //0、1、2、3、4、5、6、7、8、9、A、b、C、d、E、F的显示码
  24. unsigned char COMD_Display[8];
  25. //用来存放要显示的8位数的值

  27. unsigned char k;

  29. unsigned char KeyValue;
  30. unsigned char flag=0;
  31. char Sec=10;
  32. char xuanshou=0;
  33. unsigned char Keyflag;        //记录按键的状态，0没有，1有

  35. void Delay10ms();   //延时10ms
  36. void KeyDown();                 //检测按键函数

  38. //--声明全局函数--//
  39. void DigDisplay(); //动态显示函数

  41. void Delay(unsigned int i)                //无符号类型的int
  42. {
  43.         char j;
  44.         for(i; i > 0; i--)
  45.                 for(j = 200; j > 0; j--);
  46. }

  48. void Delay10ms2(unsigned int c)   //误差 0us
  49. {
  50.     unsigned char a,b;
  51.     for(;c>0;c--)
  52.         for(b=38;b>0;b--)
  53.             for(a=130;a>0;a--);
  54. }

  56. void BZ1()                                                   //正确抢答蜂鸣器
  57. {
  58.         unsigned int t;
  59.         for(t=0;t<1000;t++)
  60.         {
  61.                 BEEP= 1;
  62.                 Delay(10);
  63.                 BEEP= 0;
  64.                 Delay(10);
  65.         }
  66. }

  68. void BZ2()                                                   //错误抢答蜂鸣器
  69. {
  70.         unsigned int t;
  71.         for(t=0;t<1000;t++)
  72.         {
  73.                 BEEP= 1;
  74.                 Delay(10);
  75.                 BEEP= 0;
  76.                 Delay(10);
  77.         }
  78.     Delay10ms2(30);
  79.     for(t=0;t<1000;t++)
  80.         {
  81.                 BEEP= 1;
  82.                 Delay(10);
  83.                 BEEP= 0;
  84.                 Delay(10);
  85.         }
  86. }

  88. void main(void)
  89. {
  90.         unsigned char i=0;
  91.         BEEP=1;
  92.         Keyflag=0;
  93.         TMOD=0x01;                                //定时器0方式1
  94.         TH0=(65536-50000)/256;                //定时器0：50ms
  95.         TL0=(65536-50000)%256;
  96.         TH1=(65536-50000)/256;                //定时器0：50ms
  97.         TL1=(65536-50000)%256;
  98.         EA=1;                                                //开启总中断
  99.         ET1=1;TR1=1;                                //开启T1定时器  T1定时器允许中断
  100.         while(1)
  101.         {
  102.                 ET0=0;TR0=0;
  103.                 while(flag==0)
  104.                 {
  105.                         COMD_Display[0] = COMD_CODE[Sec/10%10];
  106.                         COMD_Display[1] = COMD_CODE[Sec%10];
  107.                         DigDisplay();

  109.                         if(K1==0)
  110.                         {
  111.                                 flag=1;
  112.                                 ET0=1;TR0=1;
  113.                         }

  115.                         if(K2==0)
  116.                         {
  117.                                 Sec=10;
  118.                                 COMD_Display[0] = COMD_CODE[Sec/10%10];
  119.                                 COMD_Display[1] = COMD_CODE[Sec%10];
  120.                                 flag=0;
  121.                                 P2=0xff;
  122.                                 xuanshou=0;
  123.                         }

  125.                         KeyDown();
  126.                         if(Keyflag==1)
  127.                         {                        
  128.                                 if(KeyValue<5)
  129.                                 {
  130.                                         BZ2();
  131.                                         COMD_Display[0]=COMD_CODE[(KeyValue+1)/10];
  132.                                         COMD_Display[1]=COMD_CODE[(KeyValue+1)%10];
  133.                                         xuanshou=(KeyValue+1);
  134.                                         flag=3;
  135.                                 }
  136.                                 Keyflag=0;
  137.                         }        
  138.                 }

  140.                 while(flag==1)
  141.                 {
  142.                         KeyDown();
  143.                         if(Keyflag==1)
  144.                         {               
  145.                                 Keyflag=0;
  146.                                 if(KeyValue<5)
  147.                                 {
  148.                                         COMD_Display[0]=COMD_CODE[(KeyValue+1)/10];
  149.                                         COMD_Display[1]=COMD_CODE[(KeyValue+1)%10];
  150.                                         ET0=0;TR0=0;
  151.                                         xuanshou=(KeyValue+1);
  152.                                         flag=2;
  153.                         BZ1();
  154.                                 }
  155.                         }
  156.                         DigDisplay();
  157.                 }

  159.                 ET0=0;TR0=0;
  160.                 while(flag==2)
  161.                 {
  162.                         if(K2==0)
  163.                         {
  164.                                 Sec=10;
  165.                                 COMD_Display[0] = COMD_CODE[Sec/10%10];
  166.                                 COMD_Display[1] = COMD_CODE[Sec%10];
  167.                                 flag=0;
  168.                                 P2=0xff;                                                
  169.                                 xuanshou=0;
  170.                         }
  171.                         DigDisplay();
  172.                 }




  177.                 while(flag==3)
  178.                 {
  179.                         COMD_Display[0]=COMD_CODE[15];
  180.                         COMD_Display[1]=COMD_CODE[xuanshou];
  181.                         DigDisplay();
  182.                         if(K2==0)
  183.                         {
  184.                                 Sec=10;
  185.                                 COMD_Display[0] = COMD_CODE[Sec/10%10];
  186.                                 COMD_Display[1] = COMD_CODE[Sec%10];
  187.                                 flag=0;
  188.                                 P2=0xff;
  189.                                 xuanshou=0;
  190.                                 Keyflag=0;
  191.                         }
  192.                 }



  196.         }                                
  197. }

  199. void DigDisplay()
  200. {
  201.         unsigned char i;
  202.         unsigned int j;
  203.         for(i=0;i<8;i++)
  204.         {
  205.                 switch(7-i)         //位选，选择点亮的数码管，
  206.                 {
  207.                         case(0):
  208.                                 LSA=0;LSB=0;LSC=0; break;//显示第0位
  209.                         case(1):
  210.                                 LSA=1;LSB=0;LSC=0; break;//显示第1位
  211.                         case(2):
  212.                                 LSA=0;LSB=1;LSC=0; break;//显示第2位
  213.                         case(3):
  214.                                 LSA=1;LSB=1;LSC=0; break;//显示第3位
  215.                         case(4):
  216.                                 LSA=0;LSB=0;LSC=1; break;//显示第4位
  217.                         case(5):
  218.                                 LSA=1;LSB=0;LSC=1; break;//显示第5位
  219.                         case(6):
  220.                                 LSA=0;LSB=1;LSC=1; break;//显示第6位
  221.                         case(7):
  222.                                 LSA=1;LSB=1;LSC=1; break;//显示第7位        
  223.                 }
  224.                 GPIO_DIG=COMD_Display[i];//发送段码
  225.                 j=10;                                                 //扫描间隔时间设定
  226.                 while(j--);        
  227.                 GPIO_DIG=0x00;//消隐
  228.         }
  229. }

  231. void KeyDown(void)
  232. {
  233.         JZKEY=0x0f;
  234.         if(JZKEY!=0x0f)
  235.   {
  236.                 Delay10ms();
  237.                 if(JZKEY!=0x0f)
  238.                 {
  239.                         Keyflag=1;//有按键按下
  240.                         //测试列
  241.                         JZKEY=0X0F;        
  242.                         switch(JZKEY)
  243.                         {
  244.                                 case(0X07):        KeyValue=0;break;
  245.                                 case(0X0b):        KeyValue=1;break;
  246.                                 case(0X0d): KeyValue=2;break;
  247.                                 case(0X0e):        KeyValue=3;break;
  248.                         }
  249.                         //测试行
  250.                         JZKEY=0XF0;
  251.                         Delay10ms();
  252.                         switch(JZKEY)
  253.                         {
  254.                                 case(0X70):        KeyValue=KeyValue;break;
  255.                                 case(0Xb0):        KeyValue=KeyValue+4;break;
  256.                                 case(0Xd0): KeyValue=KeyValue+8;break;
  257.                                 case(0Xe0):        KeyValue=KeyValue+12;break;
  258.                         }
  259.                         while(JZKEY!=0xf0);
  260.                 }
  261.         }
  262. }
  263. void Delay10ms(void)   
  264. {
  265.     unsigned char a,b,c;
  266.     for(c=1;c>0;c--)
  267.         for(b=38;b>0;b--)
  268.             for(a=130;a>0;a--);
  269. }

  271. void Timer0() interrupt 1                                                                //倒计时
  272. {
  273.         unsigned char i;
  274.         TH0=(65536-50000)/256;                //恢复定时器0初值
  275.         TL0=(65536-50000)%256;
  276.         if(flag==1)
  277.         i++;
  278.         if(i>=20)                                //50ms*20=1s
  279.         {
  280.                 i=0;
  281.                 Sec--;
  282.                 if(Sec==0)
  283.                 {
  284.                         ET0=0;TR0=0;
  285.             BZ2();
  286.                         flag=2;
  287.                 }
  288.                 COMD_Display[0] = COMD_CODE[Sec/10%10];
  289.                 COMD_Display[1] = COMD_CODE[Sec%10];
  290.         }
  291. }

  293. void Timer1() interrupt 3                                                           //正确LED闪烁
  294. {
  295.         TH1=(65536-50000)/256;                //恢复定时器0初值
  296.         TL1=(65536-50000)%256;
  297.         k++;
  298.         if(flag==2)
  299.         {
  300.                 if(k>=200)                        
  301.                 {
  302.                         k=0;
  303.                         if(xuanshou==1)
  304.                         {
  305.                                 LED1=!LED1;
  306.                         }
  307.                         if(xuanshou==2)
  308.                         {
  309.                                 LED2=!LED2;
  310.                         }
  311.                         if(xuanshou==3)
  312.                         {
  313.                                 LED3=!LED3;
  314.                         }
  315.                         if(xuanshou==4)
  316.                         {
  317.                                 LED4=!LED4;
  318.                         }
  319.                         if(xuanshou==5)
  320.                         {
  321.                                 LED5=!LED5;
  322.                         }

  324.                 }
  325.         }

  327.         if(flag==3)                                                                                  //错误抢答时的LED闪烁
  328.         {
  329.                 if(k>=20)                        
  330.                 {
  331.                         k=0;
  332.                         if(xuanshou==1)
  333.                         {
  334.                                 LED1=!LED1;
  335.                         }
  336.                         if(xuanshou==2)
  337.                         {
  338.                                 LED2=!LED2;
  339.                         }
  340.                         if(xuanshou==3)
  341.                         {
  342.                                 LED3=!LED3;
  343.                         }
  344.                         if(xuanshou==4)
  345.                         {
  346.                                 LED4=!LED4;
  347.                         }
  348.                         if(xuanshou==5)
  349.                         {
  350.                                 LED5=!LED5;
  351.                         }
  352.                 }     
复制代码
                           

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

使用道具 举报

沙发
ID:517466 发表于 2020-12-10 11:00 | 只看该作者
COMD_Display[0]=COMD_CODE[(KeyValue+1)/10];
COMD_Display[1]=COMD_CODE[(KeyValue+1)%10];
xuanshou=(KeyValue+1);

前两行是为了能在LED上显示选手的编号做的处理，分被显示抢答按键的10位和个位。最后一行是确定选手的按键值。因为KeyValue默认从0开始计数，对应的额选手默认从1开始，所以做加一处理。
KeyValue=0时，对应的是1号选手。KeyValue=5时，对应的是6号选手。
程序里还有计时功能，flag的几个值都有特定意思，逻辑稍微复杂一些。

评分

参与人数 1黑币 +20 收起 理由
admin + 20 回帖助人的奖励！

查看全部评分

回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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