標題: 89c51單片機32個心形流水燈設計 [打印本頁]
作者: wangsonghu    時間: 2019-4-3 10:58
標題: 89c51單片機32個心形流水燈設計
這是最近做的課程設計，用了3、4天的時間，我們是一個小組，6個人共同完成的，其中的內容也有借鑒網上的，但沒有照搬，代碼完全是自己寫的，附件里有流水燈的代碼和原理圖及仿真圖，本次設計用到的是89c51單片機，新手報到，還望海涵，原理圖和仿真是用的proteus8.3，程序的編寫用的是keil 5。

電路原理圖如下：


設計要求：
設計一個用單片機控制的心形流水燈系統(tǒng)；
LED燈數量為32個；
可以實現循環(huán)點亮、依次熄滅的基本功能；
可以實現對角閃亮、間隔閃亮、順時針閃亮、逆時針閃亮等多種功能（也可自行增加功能）。

學生需要完成的任務：
完成心形流水燈電路設計，利用Keil軟件編寫程序，Proteus軟件進行電路功能仿真，并將仿真結果采用錄屏形式生成視頻，視頻類型建議用.mp4格式，大小不超過200M。


目錄

目錄
一、總體方案設計
1、單片機的選擇
2、LED燈控制方式的比較與選擇
3、硬件設計
二、電路原理圖設計
1、時鐘電路
2、復位電路
3、顯示電路
4、電源電路
三、程序設計
1、Keil 軟件介紹
2、程序編寫設計
3、程序調試
4、電路功能仿真
附件：
1、程序代碼：
2、小組成員任務分配表

一、總體方案設計
1、單片機的選擇

單片機作為該電路的主要控制器芯片，是整個系統(tǒng)核心部分，主要負責控制LED燈的亮滅變化的速度以及變化效果。89c51單片機共有32個I/O口，能夠滿足32個流水燈的設計需求；另外80c51具有4k字節(jié)的FLASH閃存和128字節(jié)的RAM，編寫的程序很小，非常能夠滿足設計的需求；除此之外，89c51單片機還具有靈活性高且廉價的特點，綜合考慮，選擇89c51芯片作為設計的方案。

2、LED燈控制方式的比較與選擇

方案一：采用位操作的方式對32個i/o口進行操作

方案二：采用總線的方式對32個i/o口進行操作

由于采用位操作的方式，還需要聲明32個i/o口，另外在寫程序的時候語句較多，過程繁瑣；而采用總線操作的方式，則不需要聲明i/o口，與位操作相比，采用總線的方式在程序編寫時能用很少的語句實現相同的功能效果；所以，選擇方案二，即采用總線操作的方式對32個i/o口操作。

3、硬件設計

心形流水燈設計所需的系統(tǒng)應該具有：由32個發(fā)光二極管組成的顯示電路、由晶振和電容組成的時鐘電路、電源、復位電路即軟件部分。心形流水燈的硬件設計框圖如圖1-3.1所示


二、電路原理圖設計
1、時鐘電路

單片機內有一個由反相放大器所構成的振蕩電路， XTAL1 和 XTAL2 分別為振蕩電路的輸入端和輸出端。 在 XTAL1 和 XTAL2 引腳上外接石英晶體和微調電容構成并聯振蕩回路。晶振頻率設置為 11.0592MHZ, 作用是產生時鐘信號。 單片機晶振提供的時鐘頻率越高，那么單片機運行速度就越快，單片接的一切指令的執(zhí)行都是建立在單片機晶振提供的時鐘頻率紙上。電容值為 30pF, 可以起到頻率微調作用。時鐘電路如圖2-1.1所示：

2、復位電路

當輸入連續(xù)兩個機器周期以上高電平時為有效，用來完成單片機的復位初始值操作，復位后程序計數器PC=0000H，即復位后將從程序儲存器的0000H單元讀取第一條指令碼，通俗的講，就是單片機重新開始命令，防止程序走偏。復位電路如圖2-2.1所示：

3、顯示電路

單片機的 P0 口為 8 位的漏極開路的雙向 I/O 口，當 P0口作為普通的 I/O 口使用時，需要上拉電阻，這時為準雙向口。 P1 、P2、 P3 都為 8位的準雙向口，具有內部上拉電阻。圖 6 為顯示電路，單片機 I/O 口一對一直接控制 LED 燈，顯示電路中的 32 個電阻既為上拉電阻，也起到電路分壓作用，防止燒壞元器件。顯示電路如圖2-3.1所示

4、電源電路

本次課程設計，單片機正常工作要求輸出電壓為穩(wěn)定的 5V，輸出電壓能夠適應所帶負載的啟動項能。并且電路還必須簡單可靠，能夠輸出足夠大的電流，但是不至于會燒壞元器件。我們采用 USB 取電，4.8V 鋰電池供電。電源電路如圖所示， 兩個電阻起到濾波作用， 兩個電阻的作用是平衡電路中的電流，以免在只有 1 個 LED 燈亮時燒壞元器件。電源電路如圖2-4.1所示。



三、程序設計
1、Keil 軟件介紹

本次課程設計，我們采用Keil軟件進行C語言編程。Keil軟件是美國Keil Software公司開發(fā)的，它適合 WindowsXP、Win7 等系統(tǒng)，具有可視化操作界面，使用方便簡單，并且支持 C51 語言、匯編語言以及兩者混合編程等多種方式的單片機設計，KeilC51 在兼容標準 C 語言的基礎上，又增加了很多與 51系列單片機硬件相關的編譯特性，其生成的程序代碼運行的速度快，所需的存儲器空間小。

Keil 軟件已被完全集成到一個功能強大的全新環(huán)境中，該開發(fā)環(huán)境集成了文件編譯處理、編譯鏈接、項目管理、工具引用、和仿真軟件模擬器等多種功能。 Keil 軟件具有豐富的庫函數，同時也帶有功能強大的集成開發(fā)調試工具，可以自動識別所編寫程序的語法錯誤，編譯效率也很高， 能將源文件編譯為二進制機器語言代碼，其軟件調試仿真功能也很強大，能通過單步、設置斷點等功能讓編程者了解 CPU 正在進行的程序，并能監(jiān)控各變量以及各寄存器是否符合編程者的要求。

2、程序編寫設計

單片機的應用系統(tǒng)由硬件和軟件組成，在硬件原理圖搭建完成上電之后，暫時還不能看到流水燈循環(huán)點亮的現象，還需要編寫程序控制單片機管腳電平的高低變化，來實現 LED 燈的各種亮滅功能。其程序流程圖3-2.1如圖所示：


例如，先將 P0、P1、P2、P3 全部置 1，即通入高電平，用 16 進制表示為 0XFF，則 32個 LED 燈全部處于熄滅狀態(tài)。然后給 P0 口賦值0X7F，即只有 P0.0 處于低電平時，LED1 燈點亮。使用延時函數 delay，并設置延時時間為0.2秒，延時時間一到 P0 口的值就變?yōu)?0X3F, 即 P0.0和 P0.1都為高電平， LED2 也開始點亮，如此循環(huán) P0口控制的8 個 LED 燈全部點亮，
當高電平變?yōu)榈碗娖綍r， LED 燈熄滅。P1、P2、P3 口控制的 LED燈閃亮和熄滅原理同 P0 口一樣，所以就可以看到 LED 燈的流水效果了。

圖3-2.1程序設計流程圖

3、程序調試

在程序編寫好了之后，需要連接工程并編譯，經過反復的檢查、編譯、調試，程序沒有錯誤后，最后獲得目標代碼 Hex文件。將程序代碼文件調入 Proteus軟件，進行電路功能仿真，并根據仿真結果進行程序的修改和完善。所以程序的調試就顯得至關重要。其中，將每個閃爍的部分都寫成一個子函數，直接在主函數中調用即可實現閃爍的花樣和效果，各子函數與主函數的結構框圖如圖3-3.1所示：


4、電路功能仿真

在各部分電路設計的基礎上，按照總體電路圖在 Proteus上一一進行器件選擇，并連接。將電路連接好后，為各個器件選擇合適的參數，然后調入已編譯好的目標代碼Hex 文件，啟動仿真。根據 LED 燈是否發(fā)亮，判斷所設計的電路是否可以實現 32 個 LED燈依次點亮、依次熄滅、對角閃亮、對角熄滅、間隔閃亮、間隔熄滅等多種功能。電路仿真的結果為 32 個 LED 燈依次發(fā)亮、依次熄滅，并可以實現多種亮滅功能。

1







附件：1、程序代碼：
  1. #include<reg52.h>
  2. #include<intrins.h> //庫函數
  3. #define uint unsigned int
  4. #define uchar unsigned char//宏定義
  5. void delay(uint xms)//延時函數
  6. {
  7.               uint i,j;
  8.               for(i=xms;i>0;i--)
  9.                             for(j=110;j>0;j--);
  10. }
  11. void zys(uint t)//左右閃爍
  12. {
  13.               while(t--)
  14.               {
  15.                             P3=P2=0x00;
  16.                             delay(500);
  17.                             P3=P2=0xff;
  18.                             P1=P0=0x00;
  19.                             delay(500);
  20.                             P1=P0=0xff;
  21.               }
  22. }
  23. void qs(uint t)//全部閃亮
  24. {
  25.               while(t--)
  26.               {
  27.                             P0=P1=P2=P3=0xff;
  28.                             delay(300);
  29.                             P0=P1=P2=P3=0x00;
  30.                             delay(300);
  31.               }
  32.               P1=P2=P3=P0=0xff;
  33. }
  34. void ycdl(uint t)//依次點亮
  35. {
  36.               uchar code table[]={0xfe,0xfc,0xf8,0xf0,0xe0,0xc0,0x80,0x00};
  37.               uint i;
  38.               while(t--)
  39.               {
  40.                             for(i=0;i<8;i++)
  41.                                           {
  42.                                                         P0=table[i];
  43.                                                         delay(200);
  44.                                           }
  45.                             for(i=0;i<8;i++)
  46.                                           {
  47.                                                         P1=table[i];
  48.                                                         delay(200);
  49.                                           }
  50.                             for(i=0;i<8;i++)
  51.                                           {
  52.                                                         P2=table[i];
  53.                                                         delay(200);
  54.                                           }
  55.                             for(i=0;i<8;i++)
  56.                                           {
  57.                                                         P3=table[i];
  58.                                                         delay(200);
  59.                                           }
  60.               }
  61. }
  62. void ycxm (uint t)//依次熄滅
  63. {
  64.                             uchar code table[]={0xfe,0xfc,0xf8,0xf0,0xe0,0xc0,0x80,0x00};
  65.               uint i;
  66.               while(t--)
  67.               {
  68.                             P0=P1=P2=P3=0x00;
  69.                             for(i=0;i<8;i++)
  70.                                           {
  71.                                                         P0=~table[i];
  72.                                                         delay(200);
  73.                                           }
  74.                             for(i=0;i<8;i++)
  75.                                           {
  76.                                                         P1=~table[i];
  77.                                                         delay(200);
  78.                                           }
  79.                             for(i=0;i<8;i++)
  80.                                           {
  81.                                                         P2=~table[i];
  82.                                                         delay(200);
  83.                                           }
  84.                             for(i=0;i<8;i++)
  85.                                           {
  86.                                                         P3=~table[i];
  87.                                                         delay(200);
  88.                                           }
  89.               }
  90. }
  91. void jgs(uint t)//間隔閃爍
  92. {
  93.               while(t--)
  94.               {
  95.                             P0=P1=P2=P3=0xaa;
  96.                             delay(500);
  97.                             P0=P1=P2=P3=~0xaa;
  98.                             delay(500);
  99.               }
  100.               P0=P1=P2=P3=0xff;
  101.               delay(200);
  102. }

  104. void sszs(uint t)//順時針閃爍
  105. {
  106.               uchar a,i;
  107.               while(t--)
  108.               {
  109.                             a=0xfe;
  110.                             for(i=0;i<8;i++)
  111.                             {
  112.                                           P0=a;
  113.                                           delay(200);
  114.                                           a=_crol_(a,1);
  115.                             }
  116.                             P0=0xff;
  117.                             a=0xfe;
  118.                             for(i=0;i<8;i++)
  119.                             {
  120.                                           P1=a;
  121.                                           delay(200);
  122.                                           a=_crol_(a,1);
  123.                             }
  124.                             P1=0xff;
  125.                             a=0xfe;
  126.                             for(i=0;i<8;i++)
  127.                             {
  128.                                           P2=a;
  129.                                           delay(200);
  130.                                           a=_crol_(a,1);
  131.                             }
  132.                             P2=0xff;
  133.                             a=0xfe;
  134.                             for(i=0;i<8;i++)
  135.                             {
  136.                                           P3=a;
  137.                                           delay(200);
  138.                                           a=_crol_(a,1);
  139.                             }
  140.                             P3=0xff;
  141.               }
  142. }
  143. void nszs(uint t)//逆時針閃爍
  144. {
  145.               uchar a,i;
  146.               while(t--)
  147.               {
  148.                             a=0x7f;
  149.                             for(i=0;i<8;i++)
  150.                             {
  151.                                           P3=a;
  152.                                           delay(200);
  153.                                           a=_cror_(a,1);
  154.                             }
  155.                             P3=0xff;
  156.                             a=0x7f;
  157.                             for(i=0;i<8;i++)
  158.                             {
  159.                                           P2=a;
  160.                                           delay(200);
  161.                                           a=_cror_(a,1);
  162.                             }
  163.                             P2=0xff;
  164.                             a=0x7f;
  165.                             for(i=0;i<8;i++)
  166.                             {
  167.                                           P1=a;
  168.                                           delay(200);
  169.                                           a=_cror_(a,1);
  170.                             }
  171.                             P1=0xff;
  172.                             a=0x7f;
  173.                             for(i=0;i<8;i++)
  174.                             {
  175.                                           P0=a;
  176.                                           delay(200);
  177.                                           a=_cror_(a,1);
  178.                             }
  179.                             P0=0xff;
  180.               }
  181. }
  182. void djs1(uint t)//對角閃爍2個順時針
  183. {
  184.               uchar i;
  185.               uchar code table[]={0xf0,0xe1,0xc3,0x87,0x0f,0x1f,0x3f,0x7f,
  186.                                                                                                                                                           0xff,0xff,0xff,0xff,0xff,0xfe,0xfc,0xf8,0xf0,
  187.                                                                                                                                                           0xff,0xff,0xff,0xff,0xff,0xfe,0xfc,0xf8,
  188.                                                                                                                                                           0xf0,0xe1,0xc3,0x87,0x0f,0x1f,0x3f,0x7f,0xff};
  189.               while(t--)
  190.               {
  191.                             for(i=0;i<17;i++)
  192.                                           {
  193.                                                         P0=P2=table[i];
  194.                                                         P1=P3=table[i+17];
  195.                                                         delay(200);
  196.                                           }
  197.                             for(i=0;i<17;i++)
  198.                                           {
  199.                                                         P1=P3=table[i+17];
  200.                                                         P0=P2=table[i];
  201.                                                         delay(200);
  202.                                           }
  203.               }
  204.               delay(300);
  205.               P0=P1=P2=P3=0xff;
  206. }
  207. void djs2(uint t)//對角閃4個逆時針
  208. {
  209.               uchar i;
  210.               uchar code table[]={0x0f,0x87,0xc3,0xe1,0xf0,0x78,0x3c,0x1e,0x0f};
  211.               while(t--)
  212.               {
  213.                             for(i=0;i<9;i++)
  214.                                           {
  215.                                                         P1=P2=P3=P0=table[i];
  216.                                                         delay(200);
  217.                                           }
  218.               }
  219. }
  220. void sxhx(uint t)//從上往下畫心
  221. {
  222.               uchar code table[]={0xfe,0xfc,0xf8,0xf0,0xe0,0xc0,0x80,0x00,
  223.                                                                                                                                                           0x7f,0x3f,0x1f,0x0f,0x07,0x03,0x01,0x00};
  224.               uint i;
  225.               while(t--)
  226.               {
  227.                             for(i=0;i<8;i++)
  228.                                           {
  229.                                                         P0=table[i];
  230.                                                         P3=table[i+8];
  231.                                                         delay(200);
  232.                                           }
  233.                             for(i=0;i<8;i++)
  234.                                           {
  235.                                                         P1=table[i];
  236.                                                         P2=table[i+8];
  237.                                                         delay(200);
  238.                                           }
  239.                             P1=P2=P3=P0=0xff;
  240.                             delay(300);
  241.               }
  242. }

  244. void main()
  245. {
  246. while(1)
  247. {
  248. ycdl(1);
  249.               ycxm(1);
  250.               jgs(3);
  251.               sszs(1);
  252.               nszs(1);
  253.               djs1(1);
  254.                             djs2(3);
  255.                             zys(3);
  256.                             sxhx(1);
  257.                             qs(3);
  258. }
  259. }
復制代碼
全部資料51hei下載地址：
心形流水燈設計報告.doc (1.14 MB, 下載次數: 86)
心形流水燈設計報告.pdf (1.2 MB, 下載次數: 43)
作者: wangsonghu    時間: 2019-4-5 02:52
很高興能夠幫到你，當然可以借鑒
作者: 15566    時間: 2019-4-19 16:17
wangsonghu 發(fā)表于 2019-4-5 02:52
很高興能夠幫到你，當然可以借鑒

能否給我發(fā)你的電路和程序，謝謝，單片機新人。QQ郵箱：1113572709，
作者: 污漬污漬    時間: 2020-6-21 17:26
不錯不錯，感謝分享
作者: tian15517917603    時間: 2020-12-16 17:00
太有用了，很給力
作者: anli88    時間: 2020-12-28 10:02
謝謝您提供這么好的資料
作者: 馬飛飛-    時間: 2024-6-24 08:40
太牛了，鐵鐵



歡迎光臨 (http://www.torrancerestoration.com/bbs/) Powered by Discuz! X3.1