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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 89c51单片机32个心形流水灯设计
返回列表 发新帖
查看: 23766|回复: 5
打印 上一主题 下一主题
收起左侧

89c51单片机32个心形流水灯设计

  [复制链接]
跳转到指定楼层
楼主
ID:503891 发表于 2019-4-3 10:58 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
这是最近做的课程设计，用了3、4天的时间，我们是一个小组，6个人共同完成的，其中的内容也有借鉴网上的，但没有照搬，代码完全是自己写的，附件里有流水灯的代码和原理图及仿真图，本次设计用到的是89c51单片机，新手报到，还望海涵，原理图和仿真是用的proteus8.3，程序的编写用的是keil 5。

电路原理图如下：


设计要求：
设计一个用单片机控制的心形流水灯系统；
LED灯数量为32个；
可以实现循环点亮、依次熄灭的基本功能；
可以实现对角闪亮、间隔闪亮、顺时针闪亮、逆时针闪亮等多种功能（也可自行增加功能）。

学生需要完成的任务：
完成心形流水灯电路设计，利用Keil软件编写程序，Proteus软件进行电路功能仿真，并将仿真结果采用录屏形式生成视频，视频类型建议用.mp4格式，大小不超过200M。


目录

目录
一、总体方案设计
1、单片机的选择
2、LED灯控制方式的比较与选择
3、硬件设计
二、电路原理图设计
1、时钟电路
2、复位电路
3、显示电路
4、电源电路
三、程序设计
1、Keil 软件介绍
2、程序编写设计
3、程序调试
4、电路功能仿真
附件：
1、程序代码：
2、小组成员任务分配表

一、总体方案设计
1、单片机的选择

单片机作为该电路的主要控制器芯片，是整个系统核心部分，主要负责控制LED灯的亮灭变化的速度以及变化效果。89c51单片机共有32个I/O口，能够满足32个流水灯的设计需求；另外80c51具有4k字节的FLASH闪存和128字节的RAM，编写的程序很小，非常能够满足设计的需求；除此之外，89c51单片机还具有灵活性高且廉价的特点，综合考虑，选择89c51芯片作为设计的方案。

2、LED灯控制方式的比较与选择

方案一：采用位操作的方式对32个i/o口进行操作

方案二：采用总线的方式对32个i/o口进行操作

由于采用位操作的方式，还需要声明32个i/o口，另外在写程序的时候语句较多，过程繁琐；而采用总线操作的方式，则不需要声明i/o口，与位操作相比，采用总线的方式在程序编写时能用很少的语句实现相同的功能效果；所以，选择方案二，即采用总线操作的方式对32个i/o口操作。

3、硬件设计

心形流水灯设计所需的系统应该具有：由32个发光二极管组成的显示电路、由晶振和电容组成的时钟电路、电源、复位电路即软件部分。心形流水灯的硬件设计框图如图1-3.1所示


二、电路原理图设计
1、时钟电路

单片机内有一个由反相放大器所构成的振荡电路， XTAL1 和 XTAL2 分别为振荡电路的输入端和输出端。 在 XTAL1 和 XTAL2 引脚上外接石英晶体和微调电容构成并联振荡回路。晶振频率设置为 11.0592MHZ, 作用是产生时钟信号。 单片机晶振提供的时钟频率越高，那么单片机运行速度就越快，单片接的一切指令的执行都是建立在单片机晶振提供的时钟频率纸上。电容值为 30pF, 可以起到频率微调作用。时钟电路如图2-1.1所示：

2、复位电路

当输入连续两个机器周期以上高电平时为有效，用来完成单片机的复位初始值操作，复位后程序计数器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、电源电路

本次课程设计，单片机正常工作要求输出电压为稳定的 5V，输出电压能够适应所带负载的启动项能。并且电路还必须简单可靠，能够输出足够大的电流，但是不至于会烧坏元器件。我们采用 USB 取电，4.8V 锂电池供电。电源电路如图所示， 两个电阻起到滤波作用， 两个电阻的作用是平衡电路中的电流，以免在只有 1 个 LED 灯亮时烧坏元器件。电源电路如图2-4.1所示。



三、程序设计
1、Keil 软件介绍

本次课程设计，我们采用Keil软件进行C语言编程。Keil软件是美国Keil Software公司开发的，它适合 WindowsXP、Win7 等系统，具有可视化操作界面，使用方便简单，并且支持 C51 语言、汇编语言以及两者混合编程等多种方式的单片机设计，KeilC51 在兼容标准 C 语言的基础上，又增加了很多与 51系列单片机硬件相关的编译特性，其生成的程序代码运行的速度快，所需的存储器空间小。

Keil 软件已被完全集成到一个功能强大的全新环境中，该开发环境集成了文件编译处理、编译链接、项目管理、工具引用、和仿真软件模拟器等多种功能。 Keil 软件具有丰富的库函数，同时也带有功能强大的集成开发调试工具，可以自动识别所编写程序的语法错误，编译效率也很高， 能将源文件编译为二进制机器语言代码，其软件调试仿真功能也很强大，能通过单步、设置断点等功能让编程者了解 CPU 正在进行的程序，并能监控各变量以及各寄存器是否符合编程者的要求。

2、程序编写设计

单片机的应用系统由硬件和软件组成，在硬件原理图搭建完成上电之后，暂时还不能看到流水灯循环点亮的现象，还需要编写程序控制单片机管脚电平的高低变化，来实现 LED 灯的各种亮灭功能。其程序流程图3-2.1如图所示：


例如，先将 P0、P1、P2、P3 全部置 1，即通入高电平，用 16 进制表示为 0XFF，则 32个 LED 灯全部处于熄灭状态。然后给 P0 口赋值0X7F，即只有 P0.0 处于低电平时，LED1 灯点亮。使用延时函数 delay，并设置延时时间为0.2秒，延时时间一到 P0 口的值就变为 0X3F, 即 P0.0和 P0.1都为高电平， LED2 也开始点亮，如此循环 P0口控制的8 个 LED 灯全部点亮，
当高电平变为低电平时， LED 灯熄灭。P1、P2、P3 口控制的 LED灯闪亮和熄灭原理同 P0 口一样，所以就可以看到 LED 灯的流水效果了。

图3-2.1程序设计流程图

3、程序调试

在程序编写好了之后，需要连接工程并编译，经过反复的检查、编译、调试，程序没有错误后，最后获得目标代码 Hex文件。将程序代码文件调入 Proteus软件，进行电路功能仿真，并根据仿真结果进行程序的修改和完善。所以程序的调试就显得至关重要。其中，将每个闪烁的部分都写成一个子函数，直接在主函数中调用即可实现闪烁的花样和效果，各子函数与主函数的结构框图如图3-3.1所示：


4、电路功能仿真

在各部分电路设计的基础上，按照总体电路图在 Proteus上一一进行器件选择，并连接。将电路连接好后，为各个器件选择合适的参数，然后调入已编译好的目标代码Hex 文件，启动仿真。根据 LED 灯是否发亮，判断所设计的电路是否可以实现 32 个 LED灯依次点亮、依次熄灭、对角闪亮、对角熄灭、间隔闪亮、间隔熄灭等多种功能。电路仿真的结果为 32 个 LED 灯依次发亮、依次熄灭，并可以实现多种亮灭功能。

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, 下载次数: 40)

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

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

使用道具 举报

沙发
ID:503891 发表于 2019-4-5 02:52 | 只看该作者
很高兴能够帮到你，当然可以借鉴
回复

使用道具 举报

板凳
ID:355499 发表于 2019-4-19 16:17 | 只看该作者
wangsonghu 发表于 2019-4-5 02:52
很高兴能够帮到你，当然可以借鉴

能否给我发你的电路和程序，谢谢，单片机新人。QQ邮箱：1113572709，
回复

使用道具 举报

地板
ID:754119 发表于 2020-6-21 17:26 | 只看该作者
不错不错，感谢分享
回复

使用道具 举报

5#
ID:861525 发表于 2020-12-16 17:00 | 只看该作者
太有用了，很给力
回复

使用道具 举报

6#
ID:869243 发表于 2020-12-28 10:02 来自手机 | 只看该作者
谢谢您提供这么好的资料
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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