找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 2937|回复: 0
收起左侧

32位单片机控制心形LED流水灯仿真与好几种花样效果的源程序

[复制链接]
ID:264310 发表于 2017-12-20 15:43 | 显示全部楼层 |阅读模式
你们要的流水灯程序仿真原理图如下(proteus仿真工程文件可到本帖附件中下载)
0.png 0.png

附件里面有好几种效果的源程序.

单片机源程序如下:
  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. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
32位led流水灯.rar (160.21 KB, 下载次数: 26)
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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