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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 单片机四位竞赛抢答器系统Proteus仿真程序设计
返回列表 发新帖
查看: 3568|回复: 2
收起左侧

单片机四位竞赛抢答器系统Proteus仿真程序设计

[复制链接]
ID:795080 发表于 2021-1-5 17:49 | 显示全部楼层 |阅读模式
四位竞赛抢答器系统设计
1、设计一个四位竞赛抢答单片机系统，可同时供 4 名选手或 4 个代表队参加比赛，
每队设置单独的抢答按钮，编号为 1、2、3、4；
2、给节目主持人设置一个“抢答开始”控制开关，用来控制抢答开始；
3、给节目主持人设置一个“系统清除”控制开关，用来控制系统清零；
4、抢答器具有编号锁存、抢答计分、时间显示和声响提示等功能。
1）主持人按下“抢答开始”后，系统以减计时方式，显示抢答剩余时间。
2）如果抢答时间计时结束，却没有选手抢答时，本次抢答无效，系统报警提示（显
示单音，持续 2 秒）；
3）抢答时间内，若有选手按动对应的抢答按钮，此对编号立即锁存，数码管上显
示出队伍编号和此队累计分数，同时系统给出音响提示（显示单音，持续 2 秒）。
4）在主持人启动“抢答开始”键前，选手提前抢答，抢答无效，系统报警提示（显
示单音，持续 2 秒）。
5、抢答成功后，禁止其他选手抢答，优先抢答选手的编号一直保持到主持人将系
统清零为止；
6、抢答器具有利用旋钮调整抢答时间功能，时间范围 20 秒~50 秒。
  我们需要硬件操作，仿真图中的显示是根据我们用的试验箱调整的，另外我加了正误判断。其中还是有一些小的问题要改的。（懒不想改了）
需要其他功能可以自己看着改。

仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）

仿真图

仿真图

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

  4. #define u8 unsigned char
  5. #define u16 unsigned int
  6. #define LED_xianshi P0   //数码管显示端口
  7. #define LED_wei P2  //位选
  8. #define KEY_COL P3  //P3口计时信号输ru

  10. sbit start=P1^5;  //P1^5 开始抢答
  11. sbit clear=P1^4;  //清零信号

  13. sbit man1=P1^0;  //4人抢答口
  14. sbit man2=P1^1;
  15. sbit man3=P1^2;
  16. sbit man4=P1^3;

  18. sbit s1=P3^0;//对错判断
  19. sbit s2=P3^1;

  21. sbit k1=P2^0;//位选
  22. sbit k2=P2^1;
  23. sbit k3=P2^2;
  24. sbit k4=P2^3;

  26. char dc=0;

  28. int man=0;
  29. int score[4]={0,0,0,0}; //分数存储开始为0
  30. int cont=0;
  31. int state=0;  //状态

  33. int sec0=20;  //起始值
  34. int sec=20;   //调节后的值
  35. char ji=0;
  36. char si=0;
  37. sbit warningLED =P1^7;  //蜂鸣器声响控制

  39. char biaozhi=0;

  41. //u8 code seg[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71,0x00,0x40};
  42. u8 code seg[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,0x88,0x83,0xc6,0xa1,0x86,0x8e,0x11,0xbf};
  43. unsigned int T0RH,T0RL,T1RH,T1RL;
  44. u8 duan[]={0x5f,0x5f,0x5f,0x40};
  45. u8 ad0;
  46. u8 KEY_up_flag=1;
  47. u8 KEY_use=0;

  49. char code dx516[3] _at_ 0x003b;

  51. u8 flag500ms=0;  //设置标志位
  52. u8 startflag=0;
  53. u8 warning=0;
  54. unsigned char GetADCValue(unsigned char chn);  //函数申明调用
  55. extern void I2CStart();
  56. extern void I2CStop();
  57. extern unsigned char I2CReadNAK();
  58. extern bit I2CWrite(unsigned char dat);
  59. unsigned char KEYscan();  //键盘扫描
  60. void reset_init();
  61. void KEYexe(u8 val);
  62. void Duanmove(u8 Movedir);
  63. void shanshuo();

  65. int scanduicuo();



  69. void delay2s()
  70. {
  71.         TMOD=0x11;
  72.         TH1=0x3c;
  73.         TL1=0xb0;
  74.         ET1=1;
  75.         TR1=1;
  76.         EA=1;
  77. }

  79. void delay(u16 t)
  80. {
  81.         while(t--);
  82. }

  84. void chushihua()
  85. {
  86.         TMOD=0x11;
  87.         TH0=0x3c;
  88.         TL0=0xb0;
  89.         EA=1;
  90.         ET0=1;
  91.         TR0=1;
  92. }

  94. void display()
  95. {
  96.                 k4=0;
  97.                 LED_xianshi=duan[0];
  98.                 delay(255);
  99.                 k4=1;
  100.                 LED_xianshi=0x00;
  101.                
  102.                 k3=0;
  103.                 LED_xianshi=duan[1];
  104.                 delay(255);
  105.                 k3=1;
  106.                 LED_xianshi=0x00;
  107.                
  108.                 k2=0;
  109.                 LED_xianshi=duan[2];
  110.                 delay(255);
  111.                 k2=1;
  112.                 LED_xianshi=0x00;
  113.                
  114.                 k1=0;
  115.                 LED_xianshi=duan[3];
  116.                 delay(255);
  117.                 k1=1;
  118.                 LED_xianshi=0x00;
  119. }

  121. void main()
  122. {


  125.        
  126.         chushihua();
  127.        
  128.         warningLED=0;
  129.        
  130.         while(1)
  131.         {
  132.                 k4=0;
  133.                 LED_xianshi=duan[0];
  134.                 delay(255);
  135.                 k4=1;
  136.                 LED_xianshi=0x00;
  137.                
  138.                 k3=0;
  139.                 LED_xianshi=duan[1];
  140.                 delay(255);
  141.                 k3=1;
  142.                 LED_xianshi=0x00;
  143.                
  144.                 k2=0;
  145.                 LED_xianshi=duan[2];
  146.                 delay(255);
  147.                 k2=1;
  148.                 LED_xianshi=0x00;
  149.                
  150.                 k1=0;
  151.                 LED_xianshi=duan[3];
  152.                 delay(255);
  153.                 k1=1;
  154.                 LED_xianshi=0x00;
  155.                
  156.                
  157.                 KEYscan();  //判断是那个人按下
  158.                 if(state==0)    //在未开始时能进行的操作
  159.                 {
  160.                         ad0=GetADCValue(0);  //在未开始时可以设置倒计时初值；
  161.                         sec0=ad0*30/255+20;
  162.                        
  163.                         duan[3]=0xbf;
  164.                         duan[2]=0xbf;
  165.                         duan[1]=seg[sec0/10];
  166.                         duan[0]=seg[sec0%10];       
  167.                        
  168.                         delay(255);
  169.                        
  170.                         if(man!=0)
  171.                         {
  172.                                 man=0;
  173.                                 warning=1;
  174.                         }
  175.                        
  176.                         if(start==0)
  177.                         {
  178.                                 reset_init();//按下开始后倒计时 state标志位置1
  179.                                 state=1;
  180.                         }
  181.                 }
  182.                
  183.                 if(state==1)  //处于开始的状态时
  184.                 {
  185.        
  186.                         if(man!=0)
  187.                         {
  188.                                 dc=0;
  189.                                 while(!dc)
  190.                                 {
  191.                                         scanduicuo();
  192.                                        
  193.                                         k4=0;
  194.                                         LED_xianshi=seg[man];
  195.                                         delay(255);
  196.                                         k4=1;
  197.                                         LED_xianshi=0x00;
  198.                                        
  199.                                         k3=0;
  200.                                         LED_xianshi=0xbf;
  201.                                         delay(255);
  202.                                         k3=1;
  203.                                         LED_xianshi=0x00;
  204.                                        
  205.                                         k2=0;
  206.                                         LED_xianshi=0xbf;
  207.                                         delay(255);
  208.                                         k2=1;
  209.                                         LED_xianshi=0x00;
  210.                                        
  211.                                         k1=0;
  212.                                         LED_xianshi=0xbf;
  213.                                         delay(255);
  214.                                         k1=1;
  215.                                         LED_xianshi=0x00;
  216.                                        
  217.                                         if(clear==0)
  218.                                         {
  219.                                                 state=2;
  220.                                                 break;
  221.                                         }
  222.                                 }
  223.                                 score[man-1]=score[man-1]+cont; //抢到后判断对错。对了加一分，错了不加分
  224.                                 duan[3]=seg[man];
  225.                                 duan[2]=seg[17];
  226.                                 duan[1]=seg[score[man-1]/10%10];
  227.                                 duan[0]=seg[score[man-1]%10];
  228.                                
  229.                                 display();
  230.                                
  231.                                 state=2;
  232.                                 warning=1;
  233.                         }
  234.                         else
  235.                         {
  236.                                 if(flag500ms)
  237.                                 {
  238.                                         flag500ms=0;
  239.                                         sec--;
  240.                                         duan[3]=0xff;
  241.                                         duan[2]=0xff;
  242.                                         duan[1]=seg[sec/10%10];
  243.                                         duan[0]=seg[sec%10];
  244.                                         if(sec==0)
  245.                                         {
  246.                                                 warning=1;
  247.                                                 state=2;
  248.                                         }
  249.                                 }
  250.                         }
  251.                 }
  252.                 else if(state==2)
  253.                 {
  254.                         if(start==1)
  255.                         {
  256.                                 man=0x0000;
  257.                                 delay(255);
  258.                                 state=0;
  259.                         }
  260.                 }
  261.                 if(clear==0)
  262.                 {
  263.                         state=0;
  264.                         score[3]=0;
  265.                         score[2]=0;
  266.                         score[1]=0;
  267.                         score[0]=0;
  268.                         duan[3] = seg[17];
  269.                         duan[2] = seg[17];
  270.                         duan[1] = seg[17];
  271.                         duan[0] = seg[17];
  272.                        
  273.                         display();
  274.                        
  275.                         warningLED=0;
  276.                         delay(1000);
  277.                         while(!clear)  //直到清零状态结束
  278.                         {
  279.                                 display();
  280.                         }
  281.                 }
  282.                 if(warning)
  283.                 {
  284.                         warning=0x0000;
  285.                         shanshuo();
  286.                 }
  287.         }
  288. }

  290. unsigned char GetADCValue(unsigned char chn)
  291. {
  292.         unsigned char val;

  294.         I2CStart();
  295.         if(!I2CWrite(0x48<<1))
  296.         {
  297.                 I2CStop();
  298.                 return 0;
  299.         }
  300.         I2CWrite(0x40 | chn);
  301.         I2CStart();
  302.         I2CWrite(0x48<<1 | 0x01);

  304.         val = I2CReadNAK();
  305.         I2CStop();

  307.         return val;
  308. }

  310. unsigned char KEYscan()
  311. {
  312.         if(man1==0)
  313.         {
  314.                 delay(1000);
  315.                 if(man1==0)
  316.                 {
  317.                         man=1;
  318.                 }
  319.         }
  320.         if(man2==0)
  321.         {
  322.                 delay(1000);
  323.                 if(man2==0)
  324.                 {
  325.                         man=2;
  326.                 }
  327.         }
  328.         if(man3==0)
  329.         {
  330.                 delay(1000);
  331.                 if(man3==0)
  332.                 {
  333.                         man=3;
  334.                 }
  335.         }
  336.         if(man4==0)
  337.         {
  338.                 delay(1000);
  339.                 if(man4==0)
  340.                 {
  341.                         man=4;
  342.                 }
  343.         }  //扫描谁按下的
  344.         if(start==1)
  345.         {
  346.                 state=0;
  347.         }
  348.         if(start==0)
  349.         {
  350.                 state==1;
  351.         }
  352.         if(clear==0)
  353.         {
  354.                 state==2;
  355.         }
  356. }

  358. void reset_init()
  359. {
  360.         sec=sec0;
  361.         duan[3] = 0;
  362.         duan[2] = 0;
  363.         duan[1] = seg[sec/10%10];
  364.         duan[0] = seg[sec%10];
  365.        
  366.         man=0;
  367.         flag500ms=0;
  368.         TH0=0x3c;
  369.         TL0=0xb0;
  370. }

  372. void shanshuo()
  373. {

  375.         warningLED=1;
  376.         delay2s();
  377.         while(warningLED)
  378.         {
  379.                 display();
  380.         }
  381.         if(warningLED==0 || si==0)
  382.         {
  383.                 TR1=0;
  384.                 ET1=0;
  385.         }
  386. }
  387. //定时
  388. void time() interrupt 1
  389. {       
  390.         TH0=0x3c;
  391. ……………………

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

所有资料51hei提供下载:
设计1.1.zip (165.13 KB, 下载次数: 75)
回复

使用道具 举报

ID:865245 发表于 2021-5-15 18:49 | 显示全部楼层
我想知道这个break是怎么使用的
回复

使用道具 举报

ID:996762 发表于 2021-12-25 14:07 | 显示全部楼层
Chen1108 发表于 2021-5-15 18:49
我想知道这个break是怎么使用的

这个程序那里有break
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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