欧美极品高清xxxxhd,国产日产欧美最新,无码AV国产东京热AV无码,国产精品人与动性XXX,国产传媒亚洲综合一区二区,四库影院永久国产精品,毛片免费免费高清视频,福利所导航夜趣136

 找回密碼
 立即注冊

QQ登錄

只需一步，快速開始

搜索
查看: 4535|回復: 2
打印 上一主題 下一主題
收起左側

單片機四位競賽搶答器系統Proteus仿真程序設計

[復制鏈接]
跳轉到指定樓層
樓主
四位競賽搶答器系統設計
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)

分享到:  QQ好友和群QQ好友和群 QQ空間QQ空間 騰訊微博騰訊微博 騰訊朋友騰訊朋友
收藏收藏6 分享淘帖 頂頂1 踩踩
回復

使用道具 舉報

沙發
ID:865245 發表于 2021-5-15 18:49 | 只看該作者
我想知道這個break是怎么使用的
回復

使用道具 舉報

板凳
ID:996762 發表于 2021-12-25 14:07 | 只看該作者
Chen1108 發表于 2021-5-15 18:49
我想知道這個break是怎么使用的

這個程序那里有break
回復

使用道具 舉報

您需要登錄后才可以回帖 登錄 | 立即注冊

本版積分規則

小黑屋|51黑電子論壇 |51黑電子論壇6群 QQ 管理員QQ:125739409;技術交流QQ群281945664

Powered by 單片機教程網

快速回復 返回頂部 返回列表