找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 6088|回复: 5
打印 上一主题 下一主题
收起左侧

心形花样LED流水灯(带程序)

[复制链接]
跳转到指定楼层
楼主
ID:284513 发表于 2018-2-20 19:20 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
32位51单片机流水灯全部资料51hei下载地址:
心形花样LED流水灯(带程序).doc (217.5 KB, 下载次数: 22)


  使用89C52做的,原理图如下:
总共有32个LED灯,4个I/O全部用上了。
我在这里不加有LED保护电阻,用200的也可以
晶振用12M的或11.0592M也行,C1,C2用30PF。
PCB图如下:
程序是用C语言写的;
如下:
  1. #include<reg52.h>
  2. #include <intrins.h>
  3. #define              uint unsigned int
  4. #define              uchar unsigned char
  5. uchar code table[]={0xfe,0xfc,0xf8,0xf0,0xe0,0xc0,0x80,0x00}; // 逐个点亮0~7
  6. uchar code table1[]={0x7f,0x3f,0x1f,0x0f,0x07,0x03,0x01,0x00}; // 逐个点亮7~0
  7. uchar code table2[]={0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f,0xff}; // 逐个灭0~7
  8. uchar code table3[]={0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff}; // 逐个灭7~0

  9. /***********************************************************/
  10. void delay(uint t);              //延时
  11. void zg(uint t,uchar a);//两边逐个亮
  12. void qs(uint t,uchar a);//全部闪烁
  13. void zgxh(uint t,uchar a);  // 逆时针逐个点亮
  14. //void zgxh1(uint t,uchar a);  // 顺时针逐个点亮
  15. void djs(uint t,uchar a);  //对角闪
  16. void lbzgm(uint t,uchar a);//两边逐个灭
  17. //void sszgm(uint t,uchar a); // 顺时针逐个灭
  18. void nszgm(uint t,uchar a); // 逆时针逐个灭
  19. void sztl(uint t,uchar a);//顺时逐个同步亮
  20. void nztl(uint t,uchar a);//逆时逐个同步亮
  21. void sztm(uint t,uchar a);//顺时逐个同步灭
  22. void nztm(uint t,uchar a);//逆时逐个同步灭
  23. void hwzjl(uint t,uchar a); //横往中间亮
  24. void hwzjm(uint t,uchar a); //横往中间灭
  25. //void swzjl(uint t,uchar a); //竖往中间亮
  26. //void swzjm(uint t,uchar a); //竖往中间灭
  27. void nzdl(uint t,uchar a); //逆时逐段亮
  28. void nzdgl(uint t,uchar a);   //逆时逐段一个点亮
  29. void jgs(uint t,uchar a);   //间隔闪
  30. /**********************************************************/
  31. void zg(uint t,uchar a)//两边逐个亮
  32. {
  33.               uchar i,j;
  34.       for(j=0;j<a;j++)
  35.               {
  36.                               P0=P1=P2=P3=0xff;
  37.                               P0=0x7f;delay(t);
  38.                               for(i=0;i<7;i++)
  39.                               {
  40.                               P0=table1[i+1];
  41.                               P2=table1[i];
  42.                               delay(t);            
  43.                               }
  44.                               P2=0x00;P1=0xfe;
  45.                               delay(t);

  46.                               for(i=0;i<7;i++)
  47.                               {
  48.                                             P1=table[i+1];
  49.                                           P3=table1[i];
  50.                                           delay(t);
  51.                               }
  52.                               P3=0x00;delay(t);
  53.                 }
  54. }


  55. void qs(uint t,uchar a)              //全部闪烁
  56. {
  57.               uchar j;
  58.               for(j=0;j<a;j++)
  59.               {
  60.                  P0=P1=P2=P3=0xff;
  61.                  delay(t);
  62.                  P0=P1=P2=P3=0x00;
  63.                  delay(t);
  64.               }               
  65. }




  66. void zgxh(uint t,uchar a)  // 逆时针逐个点亮
  67. {
  68.               uchar i,j;
  69.               for (j=0;j<a;j++)
  70.               {
  71.                             P0=P1=P2=P3=0xff;
  72.                             for (i=0;i<8;i++)
  73.                             {
  74.                                           P0=table1[i];
  75.                                           delay(t);
  76.                             }
  77.                             for(i=0;i<8;i++)
  78.                             {
  79.                                           P1=table[i];
  80.                                           delay(t);
  81.                             }
  82.                             for(i=0;i<8;i++)
  83.                             {
  84.                                           P3=table[i];
  85.                                           delay(t);
  86.                             }
  87.                             for(i=0;i<8;i++)
  88.                             {
  89.                                           P2=table[i];
  90.                                           delay(t);
  91.                             }
  92.               }
  93. }

  94. void nszgm(uint t,uchar a) // 逆时针逐个灭
  95. {
  96.               uchar i,j;
  97.               for(j=0;j<a;j++)
  98.               {
  99.                             P0=P1=P2=P3=0x00;
  100.                             for (i=0;i<8;i++)
  101.                             {
  102.                                           P0=table3[i];delay(t);            
  103.                             }
  104.                             for (i=0;i<8;i++)
  105.                             {
  106.                                           P1=table2[i];delay(t);            
  107.                             }
  108.                             for (i=0;i<8;i++)
  109.                             {
  110.                                           P3=table2[i];delay(t);            
  111.                             }
  112.                             for (i=0;i<8;i++)
  113.                             {
  114.                                           P2=table2[i];delay(t);            
  115.                             }
  116.               }


  117. }

  118. /*
  119. void zgxh1(uint t,uchar a)  // 顺时针逐个点亮
  120. {
  121.               uchar i,j;
  122.               for (j=0;j<a;j++)
  123.               {
  124.                             P0=P1=P2=P3=0xff;
  125.                             for (i=0;i<8;i++)
  126.                             {
  127.                                           P2=table1[i];
  128.                                           delay(t);
  129.                             }
  130.                             for(i=0;i<8;i++)
  131.                             {
  132.                                           P3=table1[i];
  133.                                           delay(t);
  134.                             }
  135.                             for(i=0;i<8;i++)
  136.                             {
  137.                                           P1=table1[i];
  138.                                           delay(t);
  139.                             }
  140.                             for(i=0;i<8;i++)
  141.                             {
  142.                                           P0=table[i];
  143.                                           delay(t);
  144.                             }
  145.               }
  146. }
  147. */
  148. /*
  149. void sszgm(uint t,uchar a) // 顺时针逐个灭
  150. {
  151.               uchar i,j;
  152.               for(j=0;j<a;j++)
  153.               {
  154.                             P0=P1=P2=P3=0x00;
  155.                             for (i=0;i<8;i++)
  156.                             {
  157.                                           P2=table3[i];delay(t);            
  158.                             }
  159.                             for (i=0;i<8;i++)
  160.                             {
  161.                                           P3=table3[i];delay(t);            
  162.                             }
  163.                             for (i=0;i<8;i++)
  164.                             {
  165.                                           P1=table3[i];delay(t);            
  166.                             }
  167.                             for (i=0;i<8;i++)
  168.                             {
  169.                                           P0=table2[i];delay(t);            
  170.                             }
  171.               }


  172. }

  173. */


  174. void djs(uint t,uchar a)  //对角闪
  175. {
  176.               uchar j;
  177.               for(j=0;j<a;j++)
  178.               {
  179.                             P0=P1=P2=P3=0xff;
  180.                             P0=P3=0x00;
  181.                             delay(t);
  182.                             P0=P1=P2=P3=0xff;
  183.                             P1=P2=0x00;
  184.                             delay(t);
  185.               }
  186.             
  187. }


  188. void lbzgm(uint t,uchar a)//两边逐个灭
  189. {
  190.                 uchar i,j;
  191.                 for (j=0;j<a;j++)
  192.                 {
  193.                               P0=P2=0x00;
  194.                             P3=0x01;delay(t);
  195.                             for(i=7;i>1;i--)
  196.                             {
  197.                                           P1=table[i-1];P3=table1[i-2];
  198.                                           delay(t);
  199.                             }
  200.                             P1=0xfe;P3=0xff;delay(t);
  201.                             P1=0xff;P2=0x01;delay(t);
  202.                             for(i=7;i>1;i--)
  203.                             {
  204.                                           P0=table1[i-1];
  205.                                           P2=table1[i-2];
  206.                                           delay(t);
  207.                             }
  208.                             P0=0x7f;P2=0xff;delay(t);
  209.                             P0=0xff;delay(t);
  210.                 }
  211. }


  212. void sztl(uint t,uchar a)//顺时逐个同步亮
  213. {
  214.               uchar i,j;
  215.               for(j=0;j<a;j++)
  216.               {
  217.                             P0=P1=P2=P3=0xff;
  218.                             for(i=0;i<8;i++)
  219.                             {
  220.                                           P0=table[i];
  221.                                           P1=P2=P3=table1[i];
  222.                                           delay(t);
  223.                             }
  224.               }
  225. }

  226. void nztl(uint t,uchar a)//逆时逐个同步亮
  227. {
  228.               uchar i,j;
  229.               for(j=0;j<a;j++)
  230.               {
  231.                             P0=P1=P2=P3=0xff;
  232.                             for(i=0;i<8;i++)
  233.                             {
  234.                                           P0=table1[i];
  235.                                           P1=P2=P3=table[i];
  236.                                           delay(t);
  237.                             }
  238.               }
  239. }

  240. void sztm(uint t,uchar a)//顺时逐个同步灭
  241. {
  242.               uchar i,j;
  243.               for(j=0;j<a;j++)
  244.               {
  245.                             P0=P1=P2=P3=0x00;
  246.                             for(i=0;i<8;i++)
  247.                             {
  248.                                           P0=table2[i];
  249.                                           P1=P2=P3=table3[i];
  250.                                           delay(t);
  251.                             }
  252.               }
  253. }


  254. void nztm(uint t,uchar a)//逆时逐个同步灭
  255. {
  256.               uchar i,j;
  257.               for(j=0;j<a;j++)
  258.               {
  259.                             P0=P1=P2=P3=0xff;
  260.                             for(i=0;i<8;i++)
  261.                             {
  262.                                           P0=table3[i];
  263.                                           P1=P2=P3=table2[i];
  264.                                           delay(t);
  265.                             }
  266.               }
  267. }

  268. void hwzjl(uint t,uchar a) //横往中间亮
  269. {
  270.               uchar i,j;
  271.               for (j=0;j<a;j++)
  272.               {
  273.                             P0=P1=P2=P3=0xff;
  274.                             for(i=0;i<8;i++)
  275.                             {
  276.                                           P0=P2=P1=table1[i];
  277.                                           P3=table[i];delay(t);            
  278.                             }
  279.               }
  280. }

  281. void hwzjm(uint t,uchar a) //横往中间灭
  282. {
  283.               uchar i,j;
  284.               for (j=0;j<a;j++)
  285.               {
  286.                             P0=P1=P2=P3=0x00;
  287.                             for(i=0;i<8;i++)
  288.                             {
  289.                                           P0=P2=P1=table3[i];
  290.                                           P3=table2[i];delay(t);            
  291.                             }
  292.               }
  293. }

  294. /*
  295. void swzjl(uint t,uchar a) //竖往中间亮
  296. {
  297.               uchar i,j;
  298.               for (j=0;j<a;j++)
  299.               {
  300.                             P0=P1=P2=P3=0xff;
  301.                             for(i=0;i<8;i++)
  302.                             {
  303.                                           P0=P2=P1=table[i];
  304.                                           P3=table1[i];delay(t);            
  305.                             }
  306.               }
  307. }

  308. void swzjm(uint t,uchar a) //竖往中间灭
  309. {
  310.               uchar i,j;
  311.               for (j=0;j<a;j++)
  312.               {
  313.                             P0=P1=P2=P3=0x00;
  314.                             for(i=0;i<8;i++)
  315.                             {
  316.                                           P0=P2=P1=table2[i];
  317.                                           P3=table3[i];delay(t);            
  318.                             }
  319.               }
  320. }
  321. */
  322. void nzdl(uint t,uchar a) //逆时逐段亮
  323. {
  324.               uchar i,j;
  325.               for (j=0;j<a;j++)
  326.               {
  327.                             P0=P1=P2=P3=0xff;
  328.                             for(i=0;i<8;i++)
  329.                             {
  330.                                           P0=table1[i];
  331.                                           delay(t);
  332.                             }
  333.                             P0=0xff;
  334.                             for(i=0;i<8;i++)
  335.                             {
  336.                                           P1=table[i];
  337.                                           delay(t);
  338.                             }
  339.                             P1=0xff;
  340.                             for(i=0;i<8;i++)
  341.                             {
  342.                                           P3=table[i];
  343.                                           delay(t);
  344.                             }
  345.                             P3=0xff;
  346.                             for(i=0;i<8;i++)
  347.                             {
  348.                                           P2=table[i];
  349.                                           delay(t);
  350.                             }
  351.                             P2=0xff;                           
  352.               }
  353. }


  354. void nzdgl(uint t,uchar a)   //逆时逐段一个点亮
  355. {
  356.               uchar i,j,k,l;
  357.               for (j=0;j<a;j++)
  358.               {
  359.                             k=table1[0];
  360.                             P0=k;l=table[0];
  361.                             P1=P2=P3=l;delay(t);
  362.                             for(i=0;i<8;i++)
  363.                             {
  364.                                           k=_crol_(k,-1);
  365.                                           P0=k;
  366.                                           l=_crol_(l,1);
  367.                                           P1=P2=P3=l;
  368.                                           delay(t);
  369.                             }
  370.               }
  371. }


  372. void jgs(uint t,uchar a)   //间隔闪
  373. {
  374.               uchar j;
  375.               for (j=0;j<a;j++)
  376.               {
  377.                             P0=0x55;P1=P2=P3=0xaa;
  378.                             delay(t);
  379.                             P0=0xaa;P1=P2=P3=0x55;
  380.                             delay(t);            
  381.               }
  382. }


  383. void main()
  384. {
  385.               uchar i;

  386.               while(1)
  387.               {
  388.               zg(100,1);                                          //两边逐个亮
  389.               lbzgm(100,1);                            //两边逐个灭
  390.               jgs(300,10);
  391.               djs(100,20);  //对角闪
  392. ////////////////////////////////////////////
  393.               P1=P2=P3=0xff;
  394.               for(i=0;i<3;i++)
  395.               {
  396.               P0=0x00;delay(800);
  397.               P0=0xff;delay(800);
  398.               }
  399.               P0=0x00;
  400.               for(i=0;i<3;i++)
  401.               {
  402.               P1=0x00;delay(800);
  403.               P1=0xff;delay(800);
  404.               }
  405.               P1=0x00;
  406.               for(i=0;i<3;i++)
  407.               {
  408.               P3=0x00;delay(800);
  409.               P3=0xff;delay(800);
  410.               }
  411.               P3=0x00;
  412.               for(i=0;i<3;i++)
  413.               {
  414.               P2=0x00;delay(800);
  415.               P2=0xff;delay(800);
  416.               }
  417.               qs(500,3);



  418. /////////////////////////////////////////////

  419.               for(i=0;i<6;i++)
  420.               {
  421.               zgxh(50,1);
  422.               nszgm(50,1);
  423.               }
  424.               djs(100,20);  //对角闪
  425.               for(i=0;i<3;i++)
  426.               {
  427.               zg(100,1);                                          //两边逐个亮
  428.               lbzgm(100,1);                            //两边逐个灭
  429.               }

  430.               qs(200,10);djs(100,50);

  431.               for(i=0;i<5;i++)
  432.               {
  433.                             sztl(200,1); //顺时逐个同步亮
  434.                             nztm(200,1);
  435.                             nztl(200,1);
  436.                             sztm(200,1); //顺时逐个同步灭
  437.               }
  438.               djs(300,10);  //对角闪
  439.               nzdgl(300,10);   //逆时逐段一个点亮
  440.               jgs(300,10);   //间隔闪
  441.               for(i=0;i<3;i++)
  442.               {
  443.               zgxh(100,1);
  444.               nszgm(100,1);
  445.               }


  446. /*
  447.               for(i=0;i<5;i++)
  448.               {
  449.               zgxh1(100,1);
  450.               sszgm(100,1);
  451.               }
  452. */
  453.    nzdl(200,3); //逆时逐段亮
  454.    jgs(50,100);   //间隔闪

  455. /*/////////////////////////////////////////////////////
  456.               P0=P1=P2=P3=0xff;
  457.               for (i=0;i<8;i++)
  458.               {
  459.                             P0=table1[i];
  460.                             delay(200);
  461.               }
  462.               for (i=0;i<8;i++)
  463.               {
  464.                             P1=table[i];
  465.                             delay(200);
  466.               }
  467.               for(i=0;i<3;i++)
  468.               {
  469.                             P0=P1=0x00;delay(200);
  470.                             P0=P1=0xff;delay(200);
  471.               }

  472.               for (i=0;i<8;i++)
  473.               {
  474.                             P2=table1[i];
  475.                             delay(200);
  476.               }
  477.               for (i=0;i<8;i++)
  478.               {
  479.                             P3=table1[i];
  480.                             delay(200);
  481.               }
  482.               for(i=0;i<3;i++)
  483.               {
  484.                             P2=P3=0x00;delay(200);
  485.                             P2=P3=0xff;delay(200);
  486.               }
  487. *///////////////////////////////////////////////////
  488.             
  489.               nzdgl(50,40);   //逆时逐段一个点亮
  490.               for(i=0;i<4;i++)
  491.               {
  492.               zg(100,1);qs(100,10);
  493.               lbzgm(100,1);
  494.               }
  495. //              djs(50,100);  //对角闪
  496.             
  497.                             for(i=0;i<3;i++)
  498.               {
  499.               zgxh(100,1);
  500.               nszgm(100,1);
  501.               }


  502.      djs(1000,10);
  503.               for(i=0;i<10;i++)
  504.               {
  505.                             hwzjl(200,1); //横往中间亮
  506.                             hwzjm(200,1); //横往中间灭
  507.                  }
  508.               djs(300,10);  //对角闪
  509. /*              for(i=0;i<10;i++)
  510.               {
  511.                             swzjl(200,1); //竖往中间亮
  512.                             swzjm(200,1); //竖往中间灭
  513.               }
  514. */
  515.               for(i=0;i<5;i++)
  516.               {
  517.               zgxh(100,1);
  518.               nszgm(100,1);
  519.               }
  520.               djs(100,20);  //对角闪
  521.               zg(300,1);
  522.               lbzgm(300,1);
  523. /*
  524.               for(i=0;i<5;i++)
  525.               {
  526.               zgxh1(100,1);
  527.               sszgm(100,1);
  528.               }
  529. */
  530.               for(i=0;i<5;i++)
  531.               {
  532.                             sztl(200,1);  //顺时逐个同步亮
  533.                             nztm(200,1);
  534.                             nztl(200,1);
  535.                             sztm(200,1); //顺时逐个同步灭
  536.               }
  537.               djs(500,20);  //对角闪
  538.               djs(100,30);  //对角闪
  539.               djs(50,50);  //对角闪
  540. //              djs(10,100);  //对角闪
  541.               delay(1000);
  542.               }
  543.                            
  544. }


  545. void delay(uint t)            
  546. {
  547.               uint x,y;
  548.               for (x=t;x>0;x--)
  549.               {
  550.                             for (y=120;y>0;y--);
  551.               }
  552. }
复制代码

因为89C52的容量有限,所以还有几个方式注释掉了。

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

使用道具 举报

沙发
ID:288930 发表于 2018-3-7 22:09 | 只看该作者
很好,感谢分享
回复

使用道具 举报

板凳
ID:830783 发表于 2020-11-16 12:11 | 只看该作者
哈哈哈哈孤鸿寡鹄过过过过公共机构九宫格科技馆更好 尽快恢复恢复发放胡椒粉和经济分级分工结婚后
回复

使用道具 举报

地板
ID:543653 发表于 2020-11-16 13:25 | 只看该作者
不错,很漂亮,请问P0口子,是不是要用上拉电阻才可以吧?谢谢
回复

使用道具 举报

5#
ID:575692 发表于 2020-11-16 14:05 | 只看该作者
tdl6 发表于 2020-11-16 13:25
不错,很漂亮,请问P0口子,是不是要用上拉电阻才可以吧?谢谢

是的,P0口没有自带电阻
回复

使用道具 举报

6#
ID:50331 发表于 2020-11-16 15:12 | 只看该作者
我记得单片机总电流是有限制的,你这么多二极管全是灌电流,还没有限流电阻,一个20mA左右,这少说也有5、600mA了,芯片发热都是问题,实际没有这样做产品的
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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