亚洲春色中文字幕久久久-三上亚,一吻二脱三床四吻胸,国产真实伦对白视频全集,在线毛片观看,精品成品入口黄网,国产毛aⅴ片久久久,亚洲AV色香蕉一区二区三区老师,萧皇后A级艳片,色情日本视频更新,99久久亚洲精品日本无码

 找回密碼
 立即注冊(cè)

QQ登錄

只需一步，快速開始

搜索
查看: 3232|回復(fù): 0
打印 上一主題 下一主題
收起左側(cè)

單片機(jī)模擬霓虹燈控制器設(shè)計(jì)(40只光柱的動(dòng)態(tài)顯示)源程序

[復(fù)制鏈接]
跳轉(zhuǎn)到指定樓層
樓主
ID:640283 發(fā)表于 2019-11-12 11:14 | 只看該作者 回帖獎(jiǎng)勵(lì) |倒序?yàn)g覽 |閱讀模式
通過51單片機(jī)控制40只光柱的動(dòng)態(tài)顯示

霓虹燈作為夜幕下最常見、最閃亮的風(fēng)景，是當(dāng)代社會(huì)廣泛應(yīng)用的電子產(chǎn)品之一。本次實(shí)訓(xùn)擬運(yùn)用所學(xué)的單片機(jī)原理及應(yīng)用的基本知識(shí)，設(shè)計(jì)一模擬霓虹燈控制器，實(shí)現(xiàn)對(duì)40段LED光柱的動(dòng)態(tài)顯示和動(dòng)態(tài)速度的人工控制。系統(tǒng)結(jié)構(gòu)框圖如圖0-1所示：

二、設(shè)計(jì)任務(wù)

(羅列自己完成的任務(wù)項(xiàng)目)

1、按附件1硬件原理圖，利用Altium Designer制作PCB版，3D圖如附件2所示，焊接電路，實(shí)物圖如附件3所示；

2、編寫程序：根據(jù)讀入的4位撥碼開關(guān)的狀態(tài)來控制40位LED光柱的不同顯示方案，詳細(xì)顯示方案說明見附件4；

3、編寫程序：由按鍵控制40位LED光柱的動(dòng)態(tài)切換速度，并將表示該速度值的動(dòng)態(tài)切換時(shí)間大小顯示在2位數(shù)碼管上。

4、在任何點(diǎn)亮方案的控制時(shí)，要維持兩位數(shù)碼管的正常顯示；實(shí)時(shí)響應(yīng)任何時(shí)刻按鍵、撥碼的人工操作；并且使每次撥碼狀態(tài)的改變，從附件4方案規(guī)定的第一個(gè)顯示狀態(tài)開始顯示。

5、編寫程序：自選方案，①龜兔賽跑

                                                                                                    ②新龜兔賽跑

                                                                                                    ③花綻放的平鋪

3、LED光柱的控制思路

要想達(dá)到對(duì)上述多個(gè)外設(shè)的實(shí)時(shí)控制功能，必須做到在較短時(shí)間內(nèi)對(duì)所有外設(shè)都要控制一次，并要使對(duì)每個(gè)外設(shè)的控制時(shí)間不要過長(zhǎng)，以免影響其他外設(shè)的實(shí)時(shí)控制效果（這里特別提醒必須妥善做好按鍵去抖動(dòng)的處理），另外要設(shè)置每個(gè)外設(shè)控制程序的調(diào)用條件，以縮短主程序循環(huán)控制所有外設(shè)的時(shí)間周期，達(dá)到最好的實(shí)時(shí)控制效果。仔細(xì)斟酌并設(shè)計(jì)主程序及各外設(shè)控制程序，主程序流程參考如圖6-2所示。


任務(wù)要求1
當(dāng)撥碼開關(guān)沒有一位合上時(shí)，使光帶的第一只發(fā)光管點(diǎn)亮。

任務(wù)要求2
當(dāng)撥碼開關(guān)的第一位合上時(shí)，使光帶的第一、二、三只發(fā)光管點(diǎn)亮。

任務(wù)要求3
當(dāng)撥碼開關(guān)的第二位合上時(shí)，使光帶的第一只發(fā)光管0.5S亮0.5S暗。

任務(wù)要求4

當(dāng)撥碼開關(guān)的第一、第二位合上時(shí)，使光帶的第一、第二只發(fā)光管以當(dāng)前設(shè)定速度交替點(diǎn)亮。


任務(wù)要求5
當(dāng)撥碼開關(guān)的第三位合上時(shí)，按當(dāng)前設(shè)定速度使光帶的第一、第二?第四十只發(fā)光管循環(huán)點(diǎn)亮，點(diǎn)亮第四十只后，蜂鳴器發(fā)聲一下，再點(diǎn)亮第一只?，依次類推。

任務(wù)要求6
當(dāng)撥碼開關(guān)的第一、三位合上時(shí)，按當(dāng)前設(shè)定速度遞增循序點(diǎn)亮光帶的第一、第二?第四十只發(fā)光管，點(diǎn)亮第四十只后，蜂鳴器發(fā)聲一下，再按遞減循序點(diǎn)亮第三十九、第三十八只?第一只發(fā)光管，依次類推。

任務(wù)要求7
當(dāng)撥碼開關(guān)的第二、三位合上時(shí)，按當(dāng)前設(shè)定速度由兩邊向中央點(diǎn)亮光帶發(fā)光管，即由第一和第四十只發(fā)光管亮至第二和第三十九只發(fā)光管亮?第二十和第二十一只發(fā)光管亮，再至第一和第四十只亮?，依次類推。

任務(wù)要求8

當(dāng)撥碼開關(guān)的第一、二、三位合上時(shí)，按當(dāng)前設(shè)定速度由兩邊向中央、再由中央向兩邊點(diǎn)亮光帶發(fā)光管，即由第一和第四十只發(fā)光管亮至第二和第三十九只發(fā)光管亮?第二十和第二十一只發(fā)光管亮，再至第十九和第二十二只亮?，依次類推。


任務(wù)要求9

當(dāng)撥碼的第二、四位合上時(shí)，點(diǎn)亮方式同方案5，點(diǎn)亮速度由快（點(diǎn)亮第一只）變慢(點(diǎn)亮第四十只時(shí))再變快（點(diǎn)亮第一只），依次類推。點(diǎn)亮速度的最快速度由按鍵設(shè)定，其他速度由實(shí)際點(diǎn)亮效果調(diào)試后決定。


任務(wù)要求10

當(dāng)撥碼的第一、二、四位合上時(shí)，點(diǎn)亮方式同方案8，點(diǎn)亮速度由慢（點(diǎn)亮第一和第四十只）變快(點(diǎn)亮第二十和第二十一時(shí))再變慢（點(diǎn)亮第一和第四十只），依次類推。點(diǎn)亮速度的最快速度由按鍵設(shè)定，其他速度由實(shí)際點(diǎn)亮效果調(diào)試后決定。



自行設(shè)計(jì)方案的說明(如果有的話)

任務(wù)要求11
當(dāng)撥碼的第三、四位合上時(shí)，按當(dāng)前設(shè)定的速度，從左向又一個(gè)以兩格的速度（稱為烏龜），一個(gè)以六格的速度（稱為兔子），當(dāng)兔子離終點(diǎn)還有12格時(shí)，停下來睡覺了，烏龜開始加速，以三格的速度前進(jìn)，當(dāng)烏龜離終點(diǎn)還有三格的時(shí)候，兔子醒了，但是烏龜已經(jīng)到達(dá)了終點(diǎn)。

任務(wù)要求12
當(dāng)撥碼的第一、三、四位合上時(shí)，按當(dāng)前設(shè)定的速度，從左向又一個(gè)以兩格的速度（稱為烏龜），一個(gè)以六格的速度（稱為兔子），當(dāng)兔子離終點(diǎn)還有12格時(shí)，停下來睡覺了，烏龜開始加速，以三格的速度前進(jìn)，這次烏龜看到兔子在休息，也停下來休息，兔子醒了，輕松的跑向了終點(diǎn)。

任務(wù)要求13
當(dāng)合上第二、三、四位時(shí)，按照當(dāng)前設(shè)定的速度，由中間向兩邊兩個(gè)兩個(gè)點(diǎn)亮光帶發(fā)光管，即由第二十和二十一只發(fā)光管點(diǎn)亮，再至第十九、二十、二十一和二十二只發(fā)光管點(diǎn)亮….再至發(fā)光管全部點(diǎn)亮，以此類推。

實(shí)驗(yàn)總結(jié)：

這次實(shí)訓(xùn)是設(shè)計(jì)一個(gè)模擬霓虹燈控制器，實(shí)現(xiàn)對(duì)40段LED光柱的動(dòng)態(tài)顯示和動(dòng)態(tài)速度的人工控制。運(yùn)用到的軟件有Altium Designer、Proteus、Keil5，涉及到的知識(shí)有：Altium Designer的PCB制板，Proteus的電路圖仿真，Keil5的編程運(yùn)行，有關(guān)單片機(jī)知識(shí)。

經(jīng)過這次實(shí)訓(xùn)，我明白了以下三點(diǎn)，一，編程首先要明白自己想要實(shí)現(xiàn)什么功能，會(huì)用到哪些函數(shù)，把基本框架搭建好，并不是一開始就很長(zhǎng)的一個(gè)程序要你寫出來，可以由實(shí)現(xiàn)一個(gè)方案開始，慢慢累積，不斷完善標(biāo)志位和子函數(shù)等，逐漸變成一個(gè)可以實(shí)現(xiàn)十三個(gè)功能的程序。還有參考很重要，在不知道如何下手的時(shí)候可以看一下別人的程序，理解別人的思路，在別人的基礎(chǔ)上加入自己的理解。二，有些知識(shí)，要溫故才能知新，要通過實(shí)踐，才能知道自己哪里不足，哪里不懂，比如AD這個(gè)軟件，在去年暑假的時(shí)候已經(jīng)自己利用AD做好了一個(gè)板子，但在今年實(shí)訓(xùn)的時(shí)候制板的還是出現(xiàn)了點(diǎn)問題，最后自己把去年的視頻翻出來重新看了一遍，才制作完成。有關(guān)單片機(jī)編程也是比較模糊，特別是中斷這一部分，結(jié)合書和清翔單片機(jī)的視頻，才對(duì)編程有點(diǎn)眉目。三，要有耐心和做好實(shí)訓(xùn)的決心，軟件和硬件的結(jié)合，本身就有點(diǎn)麻煩，沒準(zhǔn)哪里就出了點(diǎn)問題，要把能想到的問題都試一遍，排查問題，找出解決辦法。


附件1、總原理圖（指導(dǎo)書）


附件2：3D圖

附件3：實(shí)物圖


附件4：基本要求：

1、當(dāng)撥碼開關(guān)沒有一位合上時(shí)，使光帶的第一只發(fā)光管點(diǎn)亮。

2、當(dāng)撥碼開關(guān)的第一位合上時(shí)，使光帶的第一、二、三只發(fā)光管點(diǎn)亮。

3、當(dāng)撥碼開關(guān)的第二位合上時(shí)，使光帶的第一只發(fā)光管0.5S亮0.5S暗。

4、當(dāng)撥碼開關(guān)的第一、第二位合上時(shí)，使光帶的第一、第二只發(fā)光管以當(dāng)前設(shè)定速度交替點(diǎn)亮。

5、當(dāng)撥碼開關(guān)的第三位合上時(shí)，按當(dāng)前設(shè)定速度使光帶的第一、第二?第四十只發(fā)光管循環(huán)點(diǎn)亮，點(diǎn)亮第四十只后，蜂鳴器發(fā)聲一下，再點(diǎn)亮第一只?，依次類推。

6、當(dāng)撥碼開關(guān)的第一、三位合上時(shí)，按當(dāng)前設(shè)定速度遞增循序點(diǎn)亮光帶的第一、第二?第四十只發(fā)光管，點(diǎn)亮第四十只后，蜂鳴器發(fā)聲一下，再按遞減循序點(diǎn)亮第三十九、第三十八只?第一只發(fā)光管，依次類推。

稍高要求：

7、當(dāng)撥碼開關(guān)的第二、三位合上時(shí)，按當(dāng)前設(shè)定速度由兩邊向中央點(diǎn)亮光帶發(fā)光管，即由第一和第四十只發(fā)光管亮至第二和第三十九只發(fā)光管亮?第二十和第二十一只發(fā)光管亮，再至第一和第四十只亮?，依次類推。

8、當(dāng)撥碼開關(guān)的第一、二、三位合上時(shí)，按當(dāng)前設(shè)定速度由兩邊向中央、再由中央向兩邊點(diǎn)亮光帶發(fā)光管，即由第一和第四十只發(fā)光管亮至第二和第三十九只發(fā)光管亮?第二十和第二十一只發(fā)光管亮，再至第十九和第二十二只亮?，依次類推。

再高要求：

9、當(dāng)撥碼的第二、四位合上時(shí)，點(diǎn)亮方式同方案5，點(diǎn)亮速度由快（點(diǎn)亮第一只）變慢(點(diǎn)亮第四十只時(shí))再變快（點(diǎn)亮第一只），依次類推。點(diǎn)亮速度的最快速度由按鍵設(shè)定，其他速度由實(shí)際點(diǎn)亮效果調(diào)試后決定。

10、當(dāng)撥碼的第一、二、四位合上時(shí)，點(diǎn)亮方式同方案8，點(diǎn)亮速度由慢（點(diǎn)亮第一和第四十只）變快(點(diǎn)亮第二十和第二十一時(shí))再變慢（點(diǎn)亮第一和第四十只），依次類推。點(diǎn)亮速度的最快速度由按鍵設(shè)定，其他速度由實(shí)際點(diǎn)亮效果調(diào)試后決定。


附件5：程序

  1. include<reg51.h>
  2. #define uint unsigned int
  3. #define uchar unsigned char
  4. uchar LED_P2[]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};//方案5
  5. uchar LED_P0[]={0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01};//方案6
  6. uchar LED_F7[]={0x81,0x42,0x24,0x18};//方案7
  7. uchar LED_F8[]={0x18,0x24,0x42,0x81};//方案8
  8. uchar LED_P6[]={0x0f,0xf0};
  9. uchar LED_P3[]={0x18,0x3c,0x7e,0xff};//方案13.light2
  10. uchar LED_P33[]={0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff};//方案13,lingt1,light0
  11. uchar LED_P7[]={0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f,0xff};//方案13,light3,light4
  12. uchar LED_P1[5]={0xfe,0xfd,0xfb,0xf7,0xef};
  13. uchar LED_P4[5]={0xfe,0xfc,0xf8,0xf0,0xe0};
  14. uchar LED_P8[2]={0xfc,0xe7};
  15. uchar code tab[11]={ 0x6f,0x06,0xcb,0xc7,0xa6,0xe5,0xec,0x07,0xef,0xa7,0x00};//共陰數(shù)碼管顯示
  16. sbit key1=P0^0;//控制
  17. sbit key2=P0^1;//調(diào)速+
  18. sbit key3=P0^2;//調(diào)速-
  19. sbit wei0=P1^0;//第0條led位控
  20. sbit wei1=P1^1;//第1條led位控
  21. sbit wei2=P1^2;//第2條led位控
  22. sbit wei3=P1^3;//第3條led位控
  23. sbit wei4=P1^4;//第4條led位控
  24. sbit weil=P1^5;//數(shù)碼管com1，左邊數(shù)碼管位選
  25. sbit weir=P1^6;//數(shù)碼管com2，右邊數(shù)碼管位選
  26. sbit bell=P1^7;
  27. uint ABC=0;//中斷標(biāo)志位
  28. uint temp;//中斷標(biāo)志位，數(shù)碼管上的速度
  29. uchar sw_value,flag0=0,c=0,av=0;
  30. bit sw_05s=5;//周期為0.5的中斷標(biāo)志位
  31. uchar shum;//數(shù)碼管控制位，我假設(shè)的，硬件里不存在，0的時(shí)候是設(shè)置狀態(tài)，1的時(shí)候是正常發(fā)光狀態(tài)
  32. uchar shuml=0,shumr=5;//數(shù)碼管右邊的，數(shù)碼管左邊的
  33. uchar sw_zdy=0;//自定義周期的中斷標(biāo)志位
  34. uchar sw_f9,sw_f10;//方案9，10的中斷標(biāo)志位
  35. uchar keydeal;//按鍵中斷標(biāo)志位
  36. uchar count=0;//按鍵中斷標(biāo)志位
  37. uchar set_control=0;//key1設(shè)置鍵中斷標(biāo)志位，1設(shè)置，0跳出
  38. uchar light0=0,light1=0,light2=0,light3=0,light4=0;
  39. bit f4_flag=0;///
  40. uchar f5_flag=0,f6_flag=0,f7_flag=0,f9_slow,f10_slow=0,f11_flag=0,f12_flag=0,f13_flag=0;
  41. void f_1();//方案1
  42. void f_2();//方案2
  43. void f_3();
  44. void f_4();
  45. void f_5();
  46. void f_6();
  47. void f_7();
  48. void f_8();
  49. void f_9();
  50. void f_10();
  51. void f_11();//龜兔賽跑
  52. void f_12();//新龜兔賽跑，兔子先掉進(jìn)陷阱，烏龜在掉進(jìn)去，烏龜讓兔子踩著自己上來，完成了比賽，然后叫來了動(dòng)物，救起了烏龜
  53. void f_13();//兩個(gè)由中間向兩邊
  54. void f_14();
  55. void f_15();
  56. void f_16();

  58. void key_deal(void)
  59. {
  60.               keydeal=P0&0x07;
  61.               if (keydeal!=0x07)//有鍵按下
  62.               {
  63.                             count ++;
  64.                             if (count >= 6)
  65.                             {
  66.                                           count=0;
  67.                                          
  68.                                          
  69.                                                         if (key1 == 0)//按下key1設(shè)置鍵
  70.                                                         {
  71.                                                                      
  72.                                                                       set_control=!set_control;//進(jìn)入設(shè)置時(shí)間狀態(tài)，或者跳出設(shè)置狀態(tài)
  73.                                                         }
  74.                                                         if (set_control == 1&&key2 == 0&&((shuml*10+shumr)<=14))//在15限速內(nèi)，按下設(shè)置后按下+鍵
  75.                                                         {
  76.                                                                       while(key2==0);
  77.                                                                       shumr++;
  78.                                                                       if (shumr == 10)
  79.                                                                       {
  80.                                                                                     shuml++;
  81.                                                                                     shumr=0;
  82.                                                                       }
  83.                                                         }
  84.                                                         if (set_control == 1&&key3 == 0&&((shuml*10+shumr)>01))//在01限速內(nèi)，按下設(shè)置后按下-鍵
  85.                                                         {
  86.                                                                       while (key3 == 0);
  87.                                                                       shumr--;
  88.                                                                       if(shumr == 255)
  89.                                                                       {
  90.                                                                                     shumr=9;
  91.                                                                                     shuml--;
  92.                                                                       }
  93.                                                         }
  94.                                           }
  95.                            
  96.               }
  97. }

  99. void delay(unsigned char x)
  100. {              unsigned char i,j;            
  101. for(i=125;i>0;i--)            
  102. for(j=x;j>0;j--);
  103. }

  105. void sw_deal()//按鍵掃描程序
  106. {   sw_value=P0;
  107.                 sw_value=(sw_value>>4);
  108.                             switch(sw_value)            
  109.               {              case 0x0f:f_1();break;            
  110.                             case 0x0e:f_2();break;            
  111.                             case 0x0d:f_3();break;            
  112.                             case 0x0c:f_4();break;            
  113.     case 0x0b:f_5();break;            
  114.                             case 0x0a:f_6();break;            
  115.                 case 0x09:f_7();break;
  116.                 case 0x08:f_8();break;
  117.                             case 0x05:f_9();break;
  118.                             case 0x04:f_10();break;
  119.                             case 0x03:f_11();break;
  120.                             case 0x02:f_12();break;
  121.                                           case 0x01:f_13();break;
  122.                                           }
  123. }



  127. void time_0(void)interrupt 1 using 1
  128. {  
  129.               TH0=(65536-2000)/256;            
  130.               TL0=(65536-2000)%256;
  131.   if (ABC > 60000)
  132.     {ABC=1;}
  133.   else                                                      
  134.                             {ABC++;}                                                                     
  135.   if(ABC%250==0)
  136.                 {sw_05s=!sw_05s;}//周期為0.5s
  137.               if(ABC%((shuml*10+shumr)*50) == 0)//按照數(shù)碼管上的時(shí)間切換周期
  138.                                                                       sw_zdy=!sw_zdy;
  139.               if(ABC%((shuml*10+shumr)*50+5*f5_flag)==0)
  140.                                                                       f9_slow=!f9_slow;
  141.               if(ABC%((shuml*10+shumr)*50-5*f7_flag+20*5)==0)
  142.                                                                       f10_slow=!f10_slow;

  144.                             switch(flag0)
  145.     {case 0:{
  146.                                                 flag0++;
  147.                                                                                     P1=0xff;
  148.                                                                                     P2=0x00;//消影
  149.                                                                                     weil=0;//開左邊數(shù)碼管的位控
  150.                                                                                     if(set_control == 1&&sw_05s==0 || set_control == 0)//處于非設(shè)置狀態(tài)，或者設(shè)置狀態(tài)下的正常發(fā)光
  151.                                                                                     {
  152.                                                                                                   P2=tab[shuml]+0x10;
  153.                                                                                     }
  154.                                                                                     else
  155.                                          P2=tab[10];//熄滅
  156.                  break;
  157.                                     }
  158.                             case 1:{
  159.                                                                                                   flag0++;
  160.                                                                                                   P1=0xff;
  161.                                                                                                   P2=0x00;
  162.                                                                                                   weir=0;//開右邊數(shù)碼管的位控
  163.                                                                                                   if(set_control == 1&&sw_05s==0 || set_control == 0)
  164.                                                                                     {
  165.                                                                                                   P2=tab[shumr];
  166.                                                                                     }
  167.                                                                                                   else
  168.                                                                                                   P2=tab[10];//熄滅
  169.                                                                                                   break;
  170.                                                            }
  171.                                                                      
  172.                             case 2:{
  173.                                                                                     flag0 ++;
  174.                                                                                     weir=1;
  175.                                          
  176.                                                                                     P2=0x00;
  177.                                                                                     wei0=0;
  178.                                                                                     if(set_control==0)//非設(shè)置狀態(tài)led常亮
  179.                                                                                     {
  180.                                                                                                   P2=light0;
  181.                                                                                     }
  182.                                                                      
  183.                                                                                     if(set_control==1)//設(shè)置狀態(tài)led常滅
  184.                                                                                     {
  185.                                                                                                 
  186.                                                                                                   P2=0x00;
  187.                                                                                     }
  188.                                                                                     break;
  189.                                                                      
  190.                                                            }
  191.                                                       
  192.                                           case 3:
  193.                                                                       {
  194.                                                                                     flag0 ++;
  195.                                                                                     wei0=1;
  196.                                                                                    
  197.                                                                                     P2=0x00;
  198.                                                                                     wei1=0;
  199.                                                                                     if(set_control==0)//非設(shè)置狀態(tài)led常亮
  200.                                                                                     {
  201.                                                                                                   P2=light1;
  202.                                                                                     }
  203.                                                                                     if(set_control==1)//設(shè)置狀態(tài)led常滅
  204.                                                                                     {
  205.                                                                                                 
  206.                                                                                                   P2=0x00;
  207.                                                                                     }
  208.                                                                                     break;
  209.                                                                       }
  210.                                                                      
  211.                                                                       case 4:
  212.                                                                       {
  213.                                                                                     flag0 ++;
  214.                                                                                     wei1=1;
  215.                                                                      
  216.                                                                                     P2=0x00;
  217.                                                                                     wei2=0;
  218.                                                                                     if(set_control==0)//非設(shè)置狀態(tài)led常亮
  219.                                                                                     {
  220.                                                                                                   P2=light2;
  221.                                                                                     }
  222.                                                                                     if(set_control==1)//設(shè)置狀態(tài)led常滅
  223.                                                                                     {
  224.                                                                                                 
  225.                                                                                                   P2=0x00;
  226.                                                                                     }
  227.                                                                                     break;
  228.                                                                       }
  229.                                                                      
  230.                                                                       case 5:
  231.                                                                       {
  232.                                                                                     flag0 ++;
  233.                                                                                     wei2=1;
  234.                                                                                    
  235.                                                                                     P2=0x00;
  236.                                                                                     wei3=0;
  237.                                                                                     if(set_control==0)//非設(shè)置狀態(tài)led常亮
  238.                                                                                     {
  239.                                                                                                   P2=light3;
  240.                                                                                     }
  241.                                                                                     if(set_control==1)//設(shè)置狀態(tài)led常滅
  242.                                                                                     {
  243.                                                                                                 
  244.                                                                                                   P2=0x00;
  245.                                                                                     }
  246.                                                                                     break;
  247.                                                                       }
  248.                                                                      
  249.                                                                       case 6:
  250.                                                                       {
  251.                                                                                     flag0=0;
  252.                                                                                     wei3=1;
  253.                                                                                     P2=0x00;
  254.                                                                                     wei4=0;
  255.                                                                                     if(set_control==0)//非設(shè)置狀態(tài)led常亮
  256.                                                                                     {
  257.                                                                                                   P2=light4;
  258.                                                                                     }
  259.                                                                                     if(set_control==1)//設(shè)置狀態(tài)led常滅
  260.                                                                                     {
  261.                                                                                                 
  262.                                                                                                   P2=0x00;
  263.                                                                                     }
  264.                                                                                     break;
  265.                                                           }
  266.                                                         }
  267.           if (sw_zdy%10==0)
  268.                                                                       {
  269.                                                                                     P0=0xff;
  270.                                                                                     sw_value=P0&0xf0;
  271.                                                                                     keydeal=P0&0x07;
  272.                                                                                     key_deal();
  273.                                                                       }                                                                                                                                                                  
  274. }            
  275.                             void main(void)
  276. {            
  277.   TMOD=0x01;            
  278.   TH0=(65536-2000)/256;
  279.               TL0=(65536-2000)%256;            
  280.               IE=0x82;
  281.               TR0=1;
  282.               P1=0xff;
  283.               P2=0x00;
  284.               while(1)
  285.               {            
  286.     sw_deal();
  287.               }
  288. }

  290. void f_1 (void)
  291. {
  292.                   light0=0x01;
  293.                   light1=0x00;
  294.                   light2=0x00;
  295.                   light3=0x00;
  296.                   light4=0x00;
  297.             
  298. }
  299. void f_2(void)//合上s1，亮三盞
  300.               {
  301.                               light0=0x07;
  302.                                           light1=0x00;
  303.                   light2=0x00;
  304.                   light3=0x00;
  305.                   light4=0x00;
  306.                  }
  307.             
  308. void f_3(void)//合上s2，0.5s交替亮滅
  309.               {            
  310.     if(sw_05s==0)
  311.                             {
  312.                               light0=0x01;
  313.                                           light1=0x00;
  314.                   light2=0x00;
  315.                   light3=0x00;
  316.                   light4=0x00;
  317.                             }
  318.                             if(sw_05s==1)
  319.                             {
  320.                               light0=0x00;
  321.                                           light1=0x00;
  322.                   light2=0x00;
  323.                   light3=0x00;
  324.                   light4=0x00;
  325.                             }
  326.               }
  327.             
  328. void f_4(void)//交替點(diǎn)亮
  329.               {            
  330.     if(sw_zdy==0)
  331.                             {
  332.                               light0=0x01;
  333.                                           light1=0x00;
  334.                   light2=0x00;
  335.                   light3=0x00;
  336.                   light4=0x00;
  337.                             }
  338.                             if(sw_zdy==1)
  339.                             {
  340.                               light0=0x02;
  341.                                           light1=0x00;
  342.                   light2=0x00;
  343.                   light3=0x00;
  344.                   light4=0x00;
  345.                             }
  346.                                           }
  347.             
  348. void f_5(void)//循環(huán)點(diǎn)亮
  349. {            
  350.               uint i;
  351.               if(sw_zdy == 0)
  352.               {            
  353.     f5_flag++;
  354.                             if(f5_flag>=0&&f5_flag<8)            
  355.                             {
  356.       light0=LED_P2[f5_flag];
  357.                                           light1=0;
  358.                                           light2=0;
  359.                                           light3=0;
  360.                                           light4=0;
  361.                             }                           
  362.                             if(f5_flag>=8&&f5_flag<16)            
  363.                             {
  364.                                           light0=0;
  365.       light1=LED_P2[f5_flag%8];
  366.                                           light2=0;
  367.                                           light3=0;
  368.                                           light4=0;
  369.                             }                           
  370.                             if(f5_flag>=16&&f5_flag<24)            
  371.                             {
  372.                                           light0=0;
  373.                                           light1=0;
  374.       light2=LED_P2[f5_flag%8];
  375.                                           light3=0;
  376.                                           light4=0;
  377.                             }
  378.                             if(f5_flag>=24&&f5_flag<32)            
  379.                             {
  380.                                           light0=0;
  381.       light1=0;
  382.                                           light2=0;
  383.                                           light3=LED_P2[f5_flag%8];
  384.                                           light4=0;
  385.                             }            
  386.                             if(f5_flag>=32&&f5_flag<40)            
  387.                             {
  388.                                           light0=0;
  389.       light1=0;
  390.                                           light2=0;
  391.                                           light3=0;
  392.                                           light4=LED_P2[f5_flag%8];
  393.                             }                           
  394.                             if(f5_flag==39)
  395.                             {
  396.                                           light0=0;
  397.       light1=0;
  398.                                           light2=0;
  399.                                           light3=0;
  400.                                           light4=LED_P2[f5_flag%8];
  401.                                           bell=0;
  402.                                           for(i=0;i<100;i++)
  403.                                           {
  404.                            
  405.                                                         bell=!bell;
  406.                                                         delay(2);
  407.                                           }
  408.      }
  409.                             if(f5_flag>=40)
  410.                             {
  411.                                          
  412.                                           f5_flag=0;
  413.                                           light0=0x01;
  414.                             }

  416.               while(sw_zdy == 0);

  418.               }

  420.               }
  421.                                          

  423. void f_6(void)
  424. {
  425.               uint i;
  426.               if(sw_zdy == 0)
  427.               {            
  428.     f6_flag++;
  429.                             if(f6_flag>=0&&f6_flag<8)            
  430.                             {
  431.       light0=LED_P2[f6_flag];
  432.                                           light1=0;
  433.                                           light2=0;
  434.                                           light3=0;
  435.                                           light4=0;
  436.                             }                           
  437.                             if(f6_flag>=8&&f6_flag<16)            
  438.                             {
  439.                                           light0=0;
  440.       light1=LED_P2[f6_flag%8];
  441.                                           light2=0;
  442.                                           light3=0;
  443.                                           light4=0;
  444.                             }                           
  445.                             if(f6_flag>=16&&f6_flag<24)            
  446.                             {
  447.                                           light0=0;
  448.                                           light1=0;
  449.       light2=LED_P2[f6_flag%8];
  450.                                           light3=0;
  451.                                           light4=0;
  452.                             }
  453.                             if(f6_flag>=24&&f6_flag<32)            
  454.                             {
  455.                                           light0=0;
  456.       light1=0;
  457.                                           light2=0;
  458.                                           light3=LED_P2[f6_flag%8];
  459.                                           light4=0;
  460.                             }            
  461.                             if(f6_flag>=32&&f6_flag<40)            
  462.                             {
  463.                                           light0=0;
  464.       light1=0;
  465.                                           light2=0;
  466.                                           light3=0;
  467.                                           light4=LED_P2[f6_flag%8];
  468.                             }                           
  469.                             if(f6_flag==39)
  470.                             {
  471.                                           light0=0;
  472.       light1=0;
  473.                                           light2=0;
  474.                                           light3=0;
  475.                                           light4=LED_P2[(f6_flag-32)%8];
  476.                                           bell=0;
  477.                                           for(i=0;i<100;i++)
  478.                                           {
  479.                                           bell=!bell;
  480.                                                         delay(2);
  481.                                           }
  482.      }
  483.                             if(f6_flag>39&&f6_flag<48)
  484.                             {
  485.                                          
  486.                                           light0=0;
  487.                                           light1=0;
  488.                                           light2=0;
  489.                                           light3=0;
  490.                                           light4=LED_P0[(f6_flag-32)%8];
  491.                             }
  492.                             if(f6_flag>=48&&f6_flag<56)
  493.                             {
  494.                                          
  495.                                           light4=0;
  496.                                           light3=LED_P0[(f6_flag-40)%8];
  497.                                           light2=0;
  498.                                           light1=0;
  499.                                           light0=0;
  500.                             }
  501.                             if(f6_flag>=56&&f6_flag<64)
  502.                             {
  503.                                          
  504.                                           light4=0;
  505.                                           light3=0;
  506.                                           light2=LED_P0[(f6_flag-48)%8];
  507.                                           light1=0;
  508.                                           light0=0;
  509.                             }
  510.                             if(f6_flag>=64&&f6_flag<72)
  511.                             {
  512.                                          
  513.                                           light4=0;
  514.                                           light3=0;
  515.                                           light2=0;
  516.                                           light1=LED_P0[(f6_flag-56)%8];
  517.                                           light0=0;
  518.                             }
  519.                             if(f6_flag>=72&&f6_flag<80)
  520.                             {
  521.                                          
  522.                                           light4=0;
  523.                                           light3=0;
  524.                                           light2=0;
  525.                                           light1=0;
  526.                                           light0=LED_P0[(f6_flag-64)%8];
  527.                             }
  528.                             if(f6_flag>=80)
  529.                             {
  530.                                           f6_flag=0;
  531.                                           light0=0x01;
  532.                                           light1=0x00;
  533.                                           light2=0x00;
  534.                                           light3=0x00;
  535.                                           light4=0x00;
  536.                             }
  537.               while(sw_zdy == 0);

  539.               }
  540. }

  542. void f_7(void)
  543.               {            
  544.                             if(sw_zdy==0)
  545.                             {
  546.                                           f7_flag++;
  547.                                           if(f7_flag>=0&&f7_flag<8)
  548.                                           {
  549.                                                         light0=LED_P2[f7_flag];
  550.                                             light1=0;
  551.                                             light2=0;
  552.                                             light3=0;
  553.                                             light4=LED_P0[f7_flag%8];
  554.                                           }
  555.                                           if(f7_flag>=8&&f7_flag<16)
  556.                                           {
  557.                                                         light0=0;
  558.                                             light1=LED_P2[f7_flag%8];
  559.                                             light2=0;
  560.                                             light3=LED_P0[f7_flag%8];
  561.                                             light4=0;
  562.                                           }
  563.                                           if(f7_flag>=16&&f7_flag<21)
  564.                                           {
  565.                                                         light0=0;
  566.                                             light1=0;
  567.                                             light2=LED_F7[f7_flag-16];
  568.                                             light3=0;
  569.                                             light4=0;
  570.                                           }
  571.                                           if(f7_flag>=21)
  572.                                           {
  573.                                                         f7_flag=0;
  574.                                                         light0=LED_P2[f7_flag%8];
  575.                                                         light1=0x00;
  576.                                                         light2=0x00;
  577.                                                         light3=0x00;
  578.                                                         light4=LED_P0[f7_flag%8];
  579.                                           }
  580.                             while(sw_zdy==0);
  581.                             }
  582.                             }
  583.             
  584. void f_8(void)
  585.               {            
  586.                             uchar i;
  587.                             if(sw_zdy==0)
  588.                             {
  589.                                           f7_flag++;
  590.                                           if(f7_flag>=0&&f7_flag<8)
  591.                                           {
  592.                                                         light0=LED_P2[f7_flag];
  593.                                             light1=0;
  594.                                             light2=0;
  595.                                             light3=0;
  596.                                             light4=LED_P0[f7_flag%8];
  597.                                           }
  598.                                           if(f7_flag>=8&&f7_flag<16)
  599.                                           {
  600.                                                         light0=0;
  601.                                             light1=LED_P2[f7_flag%8];
  602.                                             light2=0;
  603.                                             light3=LED_P0[f7_flag%8];
  604.                                             light4=0;
  605.                                           }
  606.                                           if(f7_flag>=16&&f7_flag<20)
  607.                                           {
  608.                                                         light0=0;
  609.                                             light1=0;
  610.                                             light2=LED_F7[f7_flag-16];
  611.                                             light3=0;
  612.                                             light4=0;
  613.                                           }
  614.                                           if(f7_flag==20)
  615.                                           {
  616.                                                         light0=0x00;
  617.                                                         light1=0x00;
  618.                                                         light2=0x18;
  619.                                                         light3=0x00;
  620.                                                         light4=0x00;
  621.                                                         bell=0;
  622.                                             for(i=0;i<100;i++)
  623.                                           {
  624.                                             bell=!bell;
  625.                                                         delay(2);
  626.                                           }
  627.                                           }
  628.                                          
  629.                                           if(f7_flag>20&&f7_flag<=24)
  630.                                           {
  631.                                                         light0=0;
  632.                                             light1=0;
  633.                                             light2=LED_F8[f7_flag-20];
  634.                                             light3=0;
  635.                                             light4=0;
  636.                                           }
  637.                                          
  638.                                           if(f7_flag>24&&f7_flag<32)
  639.                                           {
  640.                                                         light0=0;
  641.                                             light1=LED_P0[f7_flag%8];
  642.                                             light2=0;
  643.                                             light3=LED_P2[f7_flag-24];
  644.                                             light4=0;
  645.                                           }                           
  646.                                          
  647.                                           if(f7_flag>=32&&f7_flag<40)
  648.                                           {
  649.                                                         light0=LED_P0[f7_flag-32];
  650.                                             light1=0;
  651.                                             light2=0;
  652.                                             light3=0;
  653.                                             light4=LED_P2[f7_flag-32];
  654.                                           }
  655.                                           if(f7_flag>=40)
  656.                                           {
  657.                                                         f7_flag=0;
  658.                                           }
  659.                             while(sw_zdy==0);
  660.                             }
  661.                             }
  662.             
  663. void f_9(void)
  664. {
  665.                             uint i;
  666.               if(f9_slow == 0)
  667.               {            
  668.     f5_flag++;
  669.                             if(f5_flag>=0&&f5_flag<8)            
  670.                             {
  671.       light0=LED_P2[f5_flag];
  672.                                           light1=0;
  673.                                           light2=0;
  674.                                           light3=0;
  675.                                           light4=0;
  676.                             }                           
  677.                             if(f5_flag>=8&&f5_flag<16)            
  678.                             {
  679.                                           light0=0;
  680.       light1=LED_P2[f5_flag%8];
  681.                                           light2=0;
  682.                                           light3=0;
  683.                                           light4=0;
  684.                             }                           
  685.                             if(f5_flag>=16&&f5_flag<24)            
  686.                             {
  687.                                           light0=0;
  688.                                           light1=0;
  689.       light2=LED_P2[f5_flag%8];
  690.                                           light3=0;
  691.                                           light4=0;
  692.                             }
  693.                             if(f5_flag>=24&&f5_flag<32)            
  694.                             {
  695.                                           light0=0;
  696.       light1=0;
  697.                                           light2=0;
  698.                                           light3=LED_P2[f5_flag%8];
  699.                                           light4=0;
  700.                             }            
  701.                             if(f5_flag>=32&&f5_flag<40)            
  702.                             {
  703.                                           light0=0;
  704.       light1=0;
  705.                                           light2=0;
  706.                                           light3=0;
  707.                                           light4=LED_P2[f5_flag%8];
  708.                             }                           
  709.                             if(f5_flag==39)
  710.                             {
  711.                                           light0=0;
  712.       light1=0;
  713.                                           light2=0;
  714.                                           light3=0;
  715.                                           light4=0x80;
  716.                                           bell=0;
  717.                                           for(i=0;i<100;i++)
  718.                                           {
  719.                                           bell=!bell;
  720.                                                         delay(2);
  721.                                           }
  722.      }
  723.                             if(f5_flag>=40)
  724.                             {
  725.                                          
  726.                                           f5_flag=0;
  727.                                           light0=0x01;
  728.                             }

  730.               while(f9_slow == 0);

  732.               }

  734.                             }

  736. void f_10(void)
  737. {
  738.     uchar i;
  739.                             if(f10_slow==1)
  740.                             {
  741.                                           f7_flag++;
  742.                                           if(f7_flag>=0&&f7_flag<8)
  743.                                           {
  744.                                                         light0=LED_P2[f7_flag];
  745.                                             light1=0;
  746.                                             light2=0;
  747.                                             light3=0;
  748.                                             light4=LED_P0[f7_flag%8];
  749.                                           }
  750.                                           if(f7_flag>=8&&f7_flag<16)
  751.                                           {
  752.                                                         light0=0;
  753.                                             light1=LED_P2[f7_flag%8];
  754.                                             light2=0;
  755.                                             light3=LED_P0[f7_flag%8];
  756.                                             light4=0;
  757.                                           }
  758.                                           if(f7_flag>=16&&f7_flag<20)
  759.                                           {
  760.                                                         light0=0;
  761.                                             light1=0;
  762.                                             light2=LED_F7[f7_flag-16];
  763.                                             light3=0;
  764.                                             light4=0;
  765.                                           }
  766.                                           if(f7_flag==20)
  767.                                           {
  768.                                                         light0=0x00;
  769.                                                         light1=0x00;
  770.                                                         light2=0x18;
  771.                                                         light3=0x00;
  772.                                                         light4=0x00;
  773.                                                         bell=0;
  774.                                             for(i=0;i<100;i++)
  775.                                           {
  776.                                             bell=!bell;
  777.                                                         delay(2);
  778.                                           }
  779.                                           }
  780.                                           if(f7_flag>20&&f7_flag<=24)
  781.                                           {
  782.                                                         light0=0;
  783.                                             light1=0;
  784.                                             light2=LED_F8[f7_flag-20];
  785.                                             light3=0;
  786.                                             light4=0;
  787.                                           }
  788.                                          
  789.                                           if(f7_flag>24&&f7_flag<32)
  790.                                           {
  791.                                                         light0=0;
  792.                                             light1=LED_P0[f7_flag%8];
  793.                                             light2=0;
  794.                                             light3=LED_P2[f7_flag-24];
  795.                                             light4=0;
  796.                                           }                           
  797.                                          
  798.                                           if(f7_flag>=32&&f7_flag<40)
  799.                                           {
  800.                                                         light0=LED_P0[f7_flag-32];
  801.                                             light1=0;
  802.                                             light2=0;
  803.                                             light3=0;
  804.                                             light4=LED_P2[f7_flag-32];
  805.                                           }
  806.                                           if(f7_flag>=40)
  807.                                           {
  808.                                                         f7_flag=0;
  809.                                           }
  810.                             while(f10_slow==1);
  811.                             }

  813. }
  814. void f_11()
  815. {
  816.               uchar h;
  817.               if(sw_zdy==0)
  818.               {
  819.               switch(f11_flag)
  820.                 {
  821.                             case 0:{f11_flag++;light0=0x01;light1=0;light2=0;light3=0;light4=0;break;}
  822.                             case 1:{f11_flag++;light0=0x88;light1=0;light2=0;light3=0;light4=0;break;}
  823.                             case 2:{f11_flag++;light0=0x40;light1=0x40;light2=0;light3=0;light4=0;break;}
  824.                             case 3:{f11_flag++;light0=0;light1=0x02;light2=0x20;light3=0;light4=0;break;}
  825.                             case 4:{f11_flag++;light0=0;light1=0x10;light2=0;light3=0x10;light4=0;break;}
  826.                             case 5:{f11_flag++;light0=0;light1=0;light2=0x01;light3=0x10;light4=0;break;}
  827.                             case 6:{f11_flag++;light0=0;light1=0;light2=0x10;light3=0x10;light4=0;break;}
  828.                             case 7:{f11_flag++;light0=0;light1=0;light2=0;light3=0x11;light4=0;break;}
  829.                             case 8:{f11_flag++;light0=0;light1=0;light2=0;light3=0x10;light4=0;break;}
  830.                             case 9:{f11_flag++;light0=0;light1=0;light2=0;light3=0x10;light4=0x01;break;}
  831.                             case 10:{f11_flag++;light0=0;light1=0;light2=0;light3=0x10;light4=0x10;break;}
  832.                             case 11:{f11_flag=0;light0=0;light1=0;light2=0;light3=0x00;light4=0x88;break;}
  833.                            
  834.                 }
  835.                            
  836.                 if(f11_flag==0)
  837.               {
  838.                               for(h=0;h<50;h++)
  839.                 {bell=0;
  840.                                           delay(2);
  841.                               bell=!bell;
  842.                             }
  843.               }}
  844.                             while(sw_zdy == 0);
  845.             
  846. }

  848. void f_12()
  849. {
  850.               uchar h;
  851.               if(sw_zdy==0)
  852.               {
  853.               switch(f12_flag)
  854.                 {
  855.                             case 0:{f12_flag++;light0=0x01;light1=0;light2=0;light3=0;light4=0;break;}
  856.                             case 1:{f12_flag++;light0=0x88;light1=0;light2=0;light3=0;light4=0;break;}
  857.                             case 2:{f12_flag++;light0=0x40;light1=0x40;light2=0;light3=0;light4=0;break;}
  858.                             case 3:{f12_flag++;light0=0;light1=0x02;light2=0x20;light3=0;light4=0;break;}
  859.                             case 4:{f12_flag++;light0=0;light1=0x10;light2=0;light3=0x10;light4=0;break;}
  860.                             case 5:{f12_flag++;light0=0;light1=0;light2=0x01;light3=0x10;light4=0;break;}
  861.                             case 6:{f12_flag++;light0=0;light1=0;light2=0x10;light3=0x10;light4=0;break;}
  862.                             case 7:{f12_flag++;light0=0;light1=0;light2=0;light3=0x11;light4=0;break;}
  863.                             case 8:{f12_flag++;light0=0;light1=0;light2=0;light3=0x10;light4=0;break;}
  864.                             case 9:{f12_flag++;light0=0;light1=0;light2=0;light3=0x10;light4=0x00;break;}
  865.                             case 10:{f12_flag++;light0=0;light1=0;light2=0;light3=0x10;light4=0x02;break;}
  866.                             case 11:{f12_flag=0;light0=0;light1=0;light2=0;light3=0x10;light4=0x80;break;}
  867.                            
  868.                 }
  869.                            
  870.                 if(f12_flag==0)
  871.               {
  872.                               for(h=0;h<50;h++)
  873.                 {bell=0;
  874.                                           delay(2);
  875.                               bell=!bell;
  876.                             }
  877.               }}
  878.                             while(sw_zdy == 0);
  879.             
  880. }
  881. void f_13(void)
  882. {            
  883.             
  884.               if(sw_zdy == 0)
  885.               {            
  886.     f13_flag++;
  887.                             if(f13_flag>=0&&f13_flag<4)            
  888.                             {
  889.       light0=0;
  890.                                           light1=0;
  891.                                           light2=LED_P3[f13_flag];
  892.                                           light3=0;
  893.                                           light4=0;
  894.                             }                           
  895.                             if(f13_flag>=4&&f13_flag<12)            
  896.                             {
  897.                                           light0=0;
  898.       light1=LED_P33[f13_flag-4];
  899.                                           light2=0xff;
  900.                                           light3= LED_P7[f13_flag-4];
  901.                                           light4=0;
  902.                             }                           
  903.                             if(f13_flag>=12&&f13_flag<20)            
  904.                             {
  905.                                           light0=LED_P33[f13_flag-12];
  906.                                           light1=0xff;
  907.       light2=0xff;
  908.                                           light3=0xff;
  909.                                           light4=LED_P7[f13_flag-12];
  910.                             }
  911.                            
  912.                             if(f13_flag>=20)
  913.                             {
  914.                                          
  915.                                           f13_flag=0;
  916.                                           light2=0x18;
  917.                                           light0=0;
  918.                                           light1=0;
  919.                                           light3=0;
  920.                                           light4=0;
  921.                             }

  923.               while(sw_zdy == 0);

  925.               }

  927.               }
復(fù)制代碼


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

使用道具 舉報(bào)

本版積分規(guī)則

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

Powered by 單片機(jī)教程網(wǎng)

快速回復(fù) 返回頂部 返回列表