基于51的爱心流水灯源码，爱心灯DIY原理图

最新推荐文章于 2024-03-09 14:25:28 发布
最新推荐文章于 2024-03-09 14:25:28 发布
阅读量1w 收藏 75
点赞数 11
分类专栏： 硬件开发 文章标签： 源码 DIY 流水灯 爱心灯 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/smartexp/article/details/55817045
版权 
  1. 这不女友快生日了吗，所以就打算送他一份非常精美的，且有心意的礼物，所以就做了个非常有爱的心形LED灯
  2. 

  3. 





  1. 1.灯：采用32颗高透明5mm七彩LED设计
2.音乐：自带靓音蜂鸣器，4首歌曲轮流播放，声音清脆靓丽，后期还会增加的哦
3.红色：大红色PCB更艳丽，尽显自己的心意，作为礼品赠送更大气
4.心形：心形底板，PCB就代表我的心
5.照片：还能在中间放上心仪者的照片哦！！超有爱
6.电路：电路通过计算省略很多元件，电路更简洁，焊接容易，看着更舒服
7.焊接：多处焊接点进行优化，大焊盘更易焊接，miniUSB口也特殊处理了哦，人性化设计
8.外壳：高品质亚克力外壳更精美，透亮，
9.结构：外壳结构精心设计，只用几颗螺丝就能做到严丝合缝，抛弃有毒的胶水
10.动画：50个动画，看的眼花撩轮，心花怒放

  2. 

  3. 部分源代码
  4. 

  5. #include<reg52.h>  
#include<intrins.h>  
#define uint unsigned int  
#define uchar unsigned char  
void delays(uint xms)  
{  
    uint i,j;  
    for(i=xms;i>0;i--)  
       for(j=110;j>0;j--);  
}  
void main()  
{  
     uint i,j,n; uchar a,b,c,d;   
     for(i=0;i<1;i++)       //                                                               所有灯闪1下  
     {  
         P0=P1=P2=P3=0x00;delays(1000);  
         P0=P1=P2=P3=0xff;delays(1000);  
     }                         
                       P3=P2=0xff;                                                        //两边一起向下流水  
                       for(j=0;j<=8;j++)  
                       {  
                           P1=0xff<<j;P0=0xff<<j;delays(40);  
                       }  
                       for(j=0;j<=8;j++)  
                       {  
                           P3=0xff<<j; P2=0xff>>j;delays(40);  
                       }  
                       P0=P1=P2=P3=0x00;delays(500);  
                       for(j=0;j<8;j++)  
                       {P3=0xff<<(7-j);P2=0xff>>(7-j);delays(40);  
                       }  
                      for(j=0;j<8;j++)  
                       {  
                           P0=0xff<<(7-j);P1=0xff<<(7-j);delays(40);  
                       }                                 
                                    P3=P2=0xff;           //两边 杂乱 闪烁  
                                    for(j=0;j<=8;j++)  
                                    {P1=0xff<<j; P0=0xff<<j; delays(40);  
                                    }  
                                    for(j=0;j<=8;j++)  
                                    {P3=0xff>>j;P2=0xff<<j; delays(40);  
                                    }  
                                    P0=P1=P2=P3=0x00;delays(500);  
                                    for(j=0;j<8;j++)  
                                    {P1=0xff>>(7-j);P0=0xff>>(7-j);delays(40);  
                                    }  
                                    for(j=0;j<8;j++)  
                                    {P2=0xff>>(7-j);P3=0xff<<(7-j);delays(40);  
                                    }                                   
        P0=P1=P2=P3=0xff;    //一边向下流水  
        for(j=0;j<=8;j++)  
        { P1=0xff<<j;delays(30);  
        }        
        for(j=0;j<=8;j++)  
        {  
              P3=0xff<<j;delays(30);  
        }  
        for(j=0;j<=8;j++)  
        {  
              P2=0xff<<j;delays(30);  
        }  
        for(j=0;j<=8;j++)  
        {  
              P0=0xff>>j;delays(30);  
        }    
        P0=P1=P2=P3=0x00;  
        delays(500)  ;  
        for(j=0;j<8;j++)  
        {   
              P0=0xff>>(7-j);delays(30);  
        }  
        for(j=0;j<8;j++)  
        {   
              P2=0xff<<(7-j);delays(30);  
        }  
        for(j=0;j<8;j++)  
        {   
              P3=0xff<<(7-j);delays(30);  
        }  
        for(j=0;j<8;j++)  
        {   
              P1=0xff<<(7-j);delays(30);  
        }  
        P0=P1=P2=P3=0xff;  
        for(j=0;j<=8;j++)  
        {  
              P0=0xff<<j; delays(30);  
        }        
        for(j=0;j<=8;j++)  
        {  
              P2=0xff>>j; delays(30);  
        }  
        for(j=0;j<=8;j++)  
        {  
              P3=0xff>>j;delays(30);  
        }  
        for(j=0;j<=8;j++)  
        {  
              P1=0xff>>j;delays(30);  
        }    
        P0=P1=P2=P3=0x00;  
        delays(500)  ;  
        for(j=0;j<8;j++)  
        {   
              P1=0xff>>(7-j);delays(30);  
        }  
        for(j=0;j<8;j++)  
        {   
              P3=0xff>>(7-j);delays(30);  
        }  
        for(j=0;j<8;j++)  
        {   
              P2=0xff>>(7-j);delays(30);  
        }  
        for(j=0;j<8;j++)  
        {   
              P0=0xff<<(7-j);delays(30);  
        }  //2    
                                     P0=P2=P3=0xff ;  
                       for(i=0;i<=8;i++)  
         {   P1=0xff<<i;delays(50);  
         } delays(800);  
         for(i=0;i<8;i++)  
         {   P1=0xff>>(7-i);delays(50);  
         }  P0=P1=P2=0xff;  
              for(i=0;i<=8;i++)  
              {  P3=0xff<<i;delays(50);  
              }   delays(800);  
              for(i=0;i<8;i++)  
              {   P3=0xff>>(7-i);delays(50);  
              }P0=P1=P3=0xff;   
         for(i=0;i<=8;i++)  
         {  P2=0xff<<i;delays(50);  
                                       }   delays(800);  
         for(i=0;i<8;i++)  
                                       {   P2=0xff>>(7-i);delays(50);  
                                       } P1=P2=P3=0xff;  
              for(i=0;i<=8;i++)  
              {  P0=0xff>>i;delays(50);  
              }      delays(800);  
              for(i=0;i<8;i++)  
              {  P0=0xff<<(7-i);delays(50);  
              }   
        P2=P3=0xff;for(i=0;i<=8;i++)  
                   {  
         P0=0xff<<i;P1=0xff<<i;delays(50);  
    }delays(800);  
    for(i=0;i<8;i++)  
    {  
         P0=0xff>>(7-i);P1=0xff>>(7-i);delays(50);       
    }P0=P1=0xff;  
         for(i=0;i<=8;i++)  
         {  
             P3=0xff<<i;P2=0xff>>i;delays(50);  
         }delays(800);  
         for(i=0;i<8;i++)  
         {  
             P3=0xff>>(7-i);P2=0xff<<(7-i);delays(50);  
         }  
         for(i=0;i<3;i++)  
         {  
             P1=P3=P2=0xcc;P0=0x33;delays(500);P1=P3=P2=0x33;P0=0xcc;delays(500);  
         }  
                          P1=P3=P2=0xcc;   P0=0x33;           //首先逆时针  
                                                        for(i=0;i<120;i++)  
                                                        {      
                                                               delays(100);P0=_cror_(P0,1);P1=_crol_(P1,1);P3=_crol_(P3,1);P2=_crol_(P2,1);  
                                                        }  
                                                        delays(1500) ;  
                                                        for(i=0;i<120;i++)  
                                                        {      
                                                               delays(100); P0=_crol_(P0,1);P1=_cror_(P1,1);P3=_cror_(P3,1);P2=_cror_(P2,1);  
                                                         } delays(1000);  
    P1=P3=P2=0x0f;   P0=0xf0;           //首先逆时针  
    for(i=0;i<80;i++)  
     {      
        delays(120);P0=_cror_(P0,1);P1=_crol_(P1,1);P3=_crol_(P3,1);P2=_crol_(P2,1);  
     }  
     delays(1500) ;  
      for(i=0;i<80;i++)  
     {      
        delays(120); P0=_crol_(P0,1);P1=_cror_(P1,1);P3=_cror_(P3,1);P2=_cror_(P2,1);  
     }    
                P1=P3=P0=0x77;P2=0xee;  
                for(i=0;i<50;i++)    //四口来回转  
                {      
                        delays(100);P0=_crol_(P0,1);P1=_crol_(P1,1);P3=_crol_(P3,1);P2=_cror_(P2,1);  
                }       
  P0=P3=0xff;P1=P2=0xfe;  
                        for(i=0;i<8;i++)  
         {      delays(30);  
                P1=_crol_(P1,1);P2=_crol_(P2,1);   
         }P1=P2=0xff;P3=0xfe;P0=0x7f;  
         for(i=0;i<8;i++)  
         {      delays(30);  
                P3=_crol_(P3,1);P0=_cror_(P0,1);  
         }P0=0xfe;P3=0x7f;a=0x7f;  b=0xfe;  
      for(j=1;j<8;j++)  
      {  c=0xff<<j;d=0xff>>j;  
         P1=P2=0xfe;  
                        for(i=0;i<=7;i++)  
         {      delays(30);  
                P1=_crol_(P1,1);P2=_crol_(P2,1);  
         }P1=P2=0xff;                 
                                                      for(i=0;i<7;i++)  
                                                      {      
                P0=a&c;P3=b&d;delays(30);  
                                                             a=_cror_(a,1);b=_crol_(b,1);                                                                  
                                                      }  
       } P0=P3=0x00;b=0xfe;  
     for(j=1;j<8;j++)  
     {  d=0xff>>j;  
           for(i=0;i<7;i++)  
           {  
              P1=b&d;P2=b&d;delays(30);b=_crol_(b,1);  
           }             
     }  
  n=2;     while(n)  
          {  
             P1=P2=P3=0x7f;P0=0xfe;  
             for(i=0;i<7;i++)  
             {   delays(100);P1=_cror_(P1,1);P2=_cror_(P2,1);P3=_cror_(P3,1);P0=_crol_(P0,1);  
             } delays(100);  
             c=0xfe;d=0x7f;a=0x7f;b=0xfe;   
            for(j=0;j<9;j++)  
            {                 
               for(i=0;i<=8;i++)  
               {    
                  P1=P2=P3=c&a;P0=b&d;delays(100);  
   a=_cror_(a,1);b=_crol_(b,1);                      
               } c=_cror_(c,1);d=_crol_(d,1); a=c;b=d;  
            }n--;  
          }  
                                     P3=P2=0xff;        //两边一起向下亮  
                                     for(j=0;j<=8;j++)  
                                     {  
                                           P1=0xff<<j;P0=0xff<<j;delays(40);  
                                     }  
                                     for(j=0;j<=8;j++)  
                                     {  
                                           P3=0xff<<j; P2=0xff>>j;delays(40);  
                                     }  
while(1)                                                       //一心调频率接近的跳动  
{  
    P0=P1=P2=P3=0x00;delays(800);  
    P0=P1=P2=P3=0xff;delays(800);  
}   
}

    如果喜欢的话可以直接在淘宝里面搜索“成长路DIY”



SmartEXP
关注
  • 11
    点赞
  • 踩
  • 75
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
心形灯原理图
04-23
单片计算机即单片微型计算机。由RAM ,ROM,CPU构成，定时，计数和多种接口于一体的微控制器。它体积小，成本低，功能强，广泛应用于智能产业和工业自动化上。而51系列单片机是各单片机中最为典型和最有代表性的一种。这次课程设计通过对它的学习，应用，从而达到学习、设计、开发软、硬的能力。
51单片机心形流水灯程序代码.zip
05-06
51单片机心形流水灯程序代码，里边还有效果展示，最开始学会了led流水灯的控制，在网上找到了心形流水灯这个东西，很好玩，就打算自己写一个流水灯效果集合，使用了七彩快闪灯，后续使用七彩慢闪灯效果会更好。 原理也不难，就是利用单片机的IO引脚控制亮灯的顺序和颗数，点亮间隔时间与慢闪颜色变化结合可得到颜色渐变流动的效果。 因为想切换各个单独的效果和自动循环全部效果，所以加了一个按键控制，在非常用的32个引脚外找到第33个引脚进行控制的。曾经还打算买套件来焊接用我的程序，配置聚合物电池和充电板能充电，效果不错但卖不出去（朋友间），哈哈哈，就当做是玩耍啦。两种外形流水灯 51单片机心形流水灯程序代码，里边还有效果展示，最开始学会了led流水灯的控制，在网上找到了心形流水灯这个东西，很好玩，就打算自己写一个流水灯效果集合，使用了七彩快闪灯，后续使用七彩慢闪灯效果会更好。 原理也不难，就是利用单片机的IO引脚控制亮灯的顺序和颗数，点亮间隔时间与慢闪颜色变化结合可得到颜色渐变流动的效果。 因为想切换各个单独的效果和自动循环全部效果，所以加了一个按键控制，在非常用的32个引脚外找到第33个引脚进行控制
单片机入门，制作心形流水灯：要求用16个发光二极管排列成心形，按照不同的顺序点亮这16个灯
m0_56646930的博客
03-09 625
题目：制作电子音乐贺卡：编写程序驱动蜂鸣器播放音乐。要求在KEIL中编写程序，用PROTEUS设计电路并仿真运行。（评分标准：根据音乐播放效果评分）要求在KEIL中编写程序，用PROTEUS设计电路并仿真运行。要求在KEIL中编写程序，用PROTEUS设计电路并仿真运行。上下（自上到下、闪烁、自下到上、闪烁）左右（自左到右、闪烁、自右到左、闪烁）转圈（顺时针、闪烁、逆时针、闪烁）
基于51单片机的中断流水灯源码.zip
09-25
c51单片机流水灯 基于51单片机的中断流水灯源码.zip基于51单片机的中断流水灯源码.zip基于51单片机的中断流水灯源码.zip基于51单片机的中断流水灯源码.zip基于51单片机的中断流水灯源码.zip基于51单片机的中断流水灯源码.zip基于51单片机的中断流水灯源码.zip基于51单片机的中断流水灯源码.zip基于51单片机的中断流水灯源码.zip基于51单片机的中断流水灯源码.zip基于51单片机的中断流水灯源码.zip基于51单片机的中断流水灯源码.zip基于51单片机的中断流水灯源码.zip基于51单片机的中断流水灯源码.zip基于51单片机的中断流水灯源码.zip基于51单片机的中断流水灯源码.zip基于51单片机的中断流水灯源码.zip基于51单片机的中断流水灯源码.zip基于51单片机的中断流水灯源码.zip基于51单片机的中断流水灯源码.zip基于51单片机的中断流水灯源码.zip基于51单片机的中断流水灯源码.zip基于51单片机的中断流水灯源码.zip基于51单片机的中断流水灯源码.zip基于51单片机的中断流水灯源码.zip基于51单片机的中断流水灯源码
心形流水灯PCB及代码设计方案-电路方案
04-20
心形流水灯原理图，PCB，源程序
51单片机流水灯源码51单片机流水灯源码
06-09
51单片机流水灯源码
【单片机】心形流水灯——27种流水方式
WWWQQQEEECCC的博客
08-08 1万+
【单片机】心形流水灯之20种花式流水方式分享
自动灌溉c语言,基于51单片机设计实现的自动浇花系统的电路方案设计（原理图+源代码）...
weixin_39786706的博客
05-18 1132
代码量两百五十行左右/***************主函数*****************/void main(){delay_1ms(100);P0 = P1 = P2 = P3 = 0xff; //初始化IO口while(1){key();//独立按键程序if(key_can < 10){key_with();//按键按下要执行的程序}flag_200ms ++;if(flag_2...
基于51单片机的心形流水灯
m0_64334734的博客
09-28 7115
2、系统功能：将32颗LED接到单片机的I/O口，编译40多种流水灯状态，实现花样流水灯，将流水灯按I/O口排列成心形，即实现心形流水灯。、系统组成：单片机最小系统、32颗LED灯、电阻。5、各种状态下的LED灯：（详细观看演示视频）4、花样流水灯（心形流水灯如下）3、单片机最小系统部分如下。
C51单片机开发心形灯流水灯（C语言）
qq_57650739的博客
03-21 5140
C语言编程，C51单片机仿真电路，心形灯流水灯
【造物笔记】基于51单片机的心形流水灯
热门推荐
不定时分享与嵌入式有关的知识
12-29 1万+
基于51单片机的新型流水灯。 // 反转1圈 i = 32; a = ~(0x80000000); for(k = 0; k < i; k++) { delay(DELAY_MS / 2); a = _lror_(a, 1);
单片机心形LED流水灯电路原理图、PCB和详细源代码（SCH、PCB源文件），适用于毕业设计-电路方案
04-22
心形LED流水灯可作为一个趣味性的电子练习模块，也可以作为单片机的系统板使用，板上有程序下载口，也预留了单片机的扩展接口；板子的功能结构图如下: 单片机心形LED流水灯功能说明: 单片机:无论是散件还是成品，单片机里面都烧录有LED 流水灯的程序，装上单片机通电就可以看到LED 流水灯运行的效果。 LED 流水灯:用来显示流水灯的运行程序，有30 种花样。 DC 接口:用来给板子供电，用USB 电源线连接电脑USB 口或者手机USB 充电器可以。 电源开关:控制板子通电。 接线柱供电口:可以接5V 电源线，比如可以用3 节5V 电源供电，通过这个接线柱接入。 TTL下载口:用来给STC 单片机下载程序用，一般用USB 转TTL 模块下载程序（需要另买）。 单片机扩展口:当把板子作为单片机系统板使用时，可以焊接上排针，进行单片机扩展实验（排针需要另买）。 单片机心形LED流水灯电路原理图: 单片机心形LED流水灯PCB图: 电路城语:此资料为卖家免费分享，不提供技术支持，请大家使用前验证资料的正确性！如涉及版权问题，请联系管理员删除！ 附件包含以下资料:
心形流水灯程序
06-09
该资源是心形流水灯的一个KEIL编程程序，具有40种以上的花样，仅供参考
单片机LED爱心灯心形流水灯源码制作教程原理图PCB.zip
03-03
爱心灯源码 心形流水灯 爱心灯原理图 爱心灯源码 爱心灯PCB
5050 led7彩色控制PCB及原理
01-08
内含5050 PCB控制灯条PCB设计及原理，RGB三色灯条，用于闪灯控制
基于51单片机——爱心流水灯
06-28
51单片机爱心流水灯，用Proteus软件绘制电路图，用Keil uVision4软件编程，实现32个LED“心形”电子爱心彩灯的设计（实现5种以上不同的花样）
爱心流水灯代码
03-03
爱心流水的相关代码
爱心流水灯原理图+PCB+51单片机程序+实物效果与运行视频.rar
10-11
绚丽多彩的爱心流水灯PCB+原理图+程序 ，资料含爱心灯原理图、完整PCB工程文件（AD13版本）、51单片机程序源码、实物效果与运行视频，此项目为自主开发设计，亲测可用！ 详细介绍：51单片机控制LED彩色流水灯，适合...
51单片机流水灯源码c.zip
11-09
单片机流水灯
at89c51爱心流水灯代码
最新发布
03-31
AT89C51是一款经典的8位单片机，常用于嵌入式系统开发。爱心流水灯是一种常见的电子制作项目，下面是一个简单的AT89C51爱心流水灯代码示例： ```c #include <reg51.h> sbit LED = P1^0; // 控制LED灯的引脚 void delay(unsigned int time) // 延时函数 { unsigned int i, j; for(i = 0; i < time; i++) for(j = 0; j < 120; j++); } void main() { unsigned char pattern[] = {0x18, 0x3C, 0x7E, 0xFF, 0x7E, 0x3C, 0x18}; // 爱心图案的模式 unsigned char i; while(1) { for(i = 0; i < sizeof(pattern); i++) { LED = pattern[i]; // 控制LED灯显示爱心图案的每一行 delay(100); // 延时一段时间，控制流水灯的速度 } } } ``` 这段代码使用了P1口的第0位作为控制LED灯的引脚，通过循环显示爱心图案的每一行，并通过延时函数控制流水灯的速度。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值