找回密码
 立即注册

QQ登录

只需一步,快速开始

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

单片机心形花样流水灯000入门级DIY小作品

[复制链接]
跳转到指定楼层
楼主
51单片机做的心形花样流水灯,DIY小作品必备

电路原理图如下:


单片机源程序如下:
  1. /******************************************************************************************
  2. *说明:将32个LED分成4组LED_P0,LED_P1,LED_P3,LED_P2,每一组代表8个LED灯,也就是讲心形分成4个部分,
  3. *      如下图所示,这样,我们只需操作这些值,然后将这些值对应到相应的IO口上就可以了
  4. *
  5. *                                                              LED_P0.2                                               LED_P2.5                                       
  6. *                                                  LED_P0.3          LED_P0.1                 LED_P2.6                 LED_P2.4                               
  7. *                                          LED_P0.4                                LED_P0.0 LED_P2.7                                 LED_P2.3                       
  8. *                                  LED_P0.5                                                                                                       LED_P2.2               
  9. *                          LED_P0.6                                                                                                                       LED_P2.1       
  10. *                  LED_P0.7                                                                                                                                       LED_P2.0
  11. *                  LED_P1.0                                                                                                                                       LED_P3.7
  12. *                           LED_P1.1                                                                                                                      LED_P3.6       
  13. *                                    LED_P1.2                                                                                                   LED_P3.5               
  14. *                                             LED_P1.3                                                                                  LED_P3.4                       
  15. *                                                      LED_P1.4                                                               LED_P3.3                               
  16. *                                                               LED_P1.5                                              LED_P3.2                                       
  17. *                                                                        LED_P1.6                     LED_P3.1                                               
  18. *                                                                                   LED_P1.7 LED_P3.0                                                       
  19. *
  20. ***********************************************************************************************/

  21. #include <reg52.h>
  22. #define        uint        unsigned int
  23. #define        uchar        unsigned char

  24. #define FOSC 12000000L //晶振设置,使用11.0592M Hz 6T双速倍模式

  25. volatile uchar LED_P0 = 0xff;
  26. volatile uchar LED_P1 = 0xff;
  27. volatile uchar LED_P2 = 0xff;
  28. volatile uchar LED_P3 = 0xff;

  29. #define SCENE_COUNT 20//定义循环播放发的数量

  30. //可自定义场景,按场景顺序播放多种状态
  31. uchar scene[SCENE_COUNT] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};

  32. uchar code table0[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};//LED从低位往高位移
  33. uchar code table1[]={0x7f,0xbf,0xdf,0xef,0xf7,0xfb,0xfd,0xfe};//LED从高位往低位移
  34. uchar code table2[]={0xfe,0xfc,0xf8,0xf0,0xe0,0xc0,0x80,0x00};//LED从1个亮到8个都点亮(从低位往高位)
  35. uchar code table3[]={0x7f,0x3f,0x1f,0x0f,0x07,0x03,0x01,0x00};//LED从1个亮到8个都点亮(从高位往低位)
  36. uchar code table4[]={0x00,0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f,0xff};//LED从8个全亮到一个都不亮(从低位往高位)
  37. uchar code table5[]={0x00,0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff};//LED从8个全亮到一个都不亮(从高位往低位)
  38. uchar code table6[]={0xfe,0xfc,0xfa,0xf6,0xee,0xde,0xbe,0x7e};//LED从低位往高位移(最低位始终为0)
  39. uchar code table7[]={0x7f,0x3f,0x5f,0x6f,0x77,0x7b,0x7d,0x7e};//LED从高位往低位移(最高位始终为0)
  40. uchar i,j;                //定义循环变量
  41. uint tt=70;                //定义时间指数
  42.        
  43. //延时函数
  44. void Delayms(uint ms)
  45. {
  46.         uint x,y;
  47.         for(x=ms;x>0;x--)
  48.         for(y=125;y>0;y--);
  49. }

  50. //将LED_P0,LED_P1,LED_P3,LED_P2的值的对应到具体IO口上,并延时
  51. void Display(uint time)       
  52. {
  53.         P0 = ((LED_P0 & 0xfe)>>1) + ((LED_P1 & 0x01)<<7);
  54.        
  55.         P1 = ((LED_P1 & 0xfe)>>1) + ((LED_P3 & 0x01)<<7);
  56.        
  57.         P3 = ((LED_P3 & 0xfe)>>1) + ((LED_P2 & 0x01)<<7);
  58.        
  59.         P2 = ((LED_P2 & 0xfe)>>1) + ((LED_P0 & 0x01)<<7);
  60.        
  61.         Delayms(time);
  62. }

  63. //状态0 所有LED闪烁3次
  64. void disp0()                       
  65. {
  66.         for(i=0;i<3;i++)
  67.         {
  68.                 LED_P0=0x00; LED_P2=0x00; LED_P3=0x00; LED_P1=0x00;
  69.                 Display(300);
  70.                 LED_P0=0xff; LED_P2=0xff; LED_P3=0xff; LED_P1=0xff;
  71.                 Display(300);
  72.         }
  73. }

  74. //状态1 LED顺时针转一圈
  75. void disp1()                       
  76. {
  77.         for(i=0;i<8;i++)
  78.         {
  79.                 LED_P2=table1[i];
  80.                 Display(100);
  81.         }
  82.         LED_P2=0xff;
  83.         for(i=0;i<8;i++)
  84.         {
  85.                 LED_P3=table1[i];
  86.                 Display(100);
  87.         }
  88.         LED_P3=0xff;
  89.         for(i=0;i<8;i++)
  90.         {
  91.                 LED_P1=table1[i];        
  92.                 Display(100);
  93.         }
  94.         LED_P1=0xff;
  95.         for(i=0;i<8;i++)
  96.         {
  97.                 LED_P0=table1[i];
  98.                 Display(100);
  99.         }
  100.         LED_P0=0xff;
  101. }

  102. //状态2 LED逆时针转一圈
  103. void disp2()                       
  104. {
  105.         for(i=0;i<8;i++)
  106.         {
  107.                 LED_P0=table0[i];
  108.                 Display(100);
  109.         }
  110.         LED_P0=0xff;
  111.         for(i=0;i<8;i++)
  112.         {
  113.                 LED_P1=table0[i];
  114.                 Display(100);
  115.         }
  116.         LED_P1=0xff;
  117.         for(i=0;i<8;i++)
  118.         {
  119.                 LED_P3=table0[i];
  120.                 Display(100);
  121.         }
  122.         LED_P3=0xff;
  123.         for(i=0;i<8;i++)
  124.         {
  125.                 LED_P2=table0[i];
  126.                 Display(100);
  127.         }
  128.         LED_P2=0xff;
  129. }

  130. //状态3 4个LED同时顺时、逆时针移动1/4圈
  131. void disp3()                       
  132. {
  133.         for(i=0;i<8;i++)
  134.         {
  135.                 LED_P0=table0[i];
  136.                 LED_P1=table1[i];
  137.                 LED_P2=table1[i];
  138.                 LED_P3=table0[i];
  139.                 Display(100);
  140.         }
  141.         for(i=0;i<8;i++)
  142.         {
  143.                 LED_P0=table1[i];
  144.                 LED_P1=table0[i];
  145.                 LED_P2=table0[i];
  146.                 LED_P3=table1[i];
  147.                 Display(100);
  148.         }
  149.         LED_P3=0xff; LED_P0=0xff;
  150. }

  151. //状态4  2个LED同时顺时针移动半圈
  152. void disp4()                       
  153. {
  154.         for(i=0;i<8;i++)
  155.         {
  156.                 LED_P2=table1[i];
  157.                 LED_P1=table1[i];
  158.                 Display(100);
  159.         }
  160.         LED_P2=0xff; LED_P1=0xff;
  161.         for(i=0;i<8;i++)
  162.         {
  163.                 LED_P3=table1[i];
  164.                 LED_P0=table1[i];
  165.                 Display(100);
  166.         }
  167.         LED_P3=0xff; LED_P0=0xff;
  168. }

  169. //状态5  2个LED同时逆时针移动半圈
  170. void disp5()                       
  171. {
  172.         for(i=0;i<8;i++)
  173.         {
  174.                 LED_P0=table0[i];
  175.                 LED_P3=table0[i];
  176.                 Display(100);
  177.         }
  178.         LED_P0=0xff; LED_P3=0xff;
  179.         for(i=0;i<8;i++)
  180.         {
  181.                 LED_P1=table0[i];
  182.                 LED_P2=table0[i];
  183.                 Display(100);
  184.         }
  185.         LED_P1=0xff; LED_P2=0xff;
  186. }

  187. //状态6 LED自上而下逐渐点亮(一半点亮一半不亮)
  188. void disp6()                       
  189. {
  190.         for(i=0;i<8;i++)
  191.         {
  192.                 LED_P0=table2[i];
  193.                 LED_P2=table3[i];
  194.                 Display(100);
  195.         }
  196.         LED_P0=0xff; LED_P2=0xff;
  197.         for(i=0;i<8;i++)
  198.         {
  199.                 LED_P1=table2[i];
  200.                 LED_P3=table3[i];
  201.                 Display(100);
  202.         }
  203.         LED_P1=0xff; LED_P3=0xff;
  204. }

  205. //状态7 LED自下而上逐渐点亮(直到全部点亮)
  206. void disp7()                       
  207. {
  208.         for(i=0;i<8;i++)
  209.         {
  210.                 LED_P1=table3[i];
  211.                 LED_P3=table2[i];
  212.                 Display(100);
  213.         }
  214.         for(i=0;i<8;i++)
  215.         {
  216.                 LED_P0=table2[i];
  217.                 LED_P2=table2[i];
  218.                 Display(100);
  219.         }
  220. }

  221. //状态8 间断8格的4个LED亮并逆时针旋转
  222. void disp8()                       
  223. {
  224.         for(j=0;j<2;j++)
  225.         {
  226.                 for(i=0;i<8;i++)
  227.                 {
  228.                         LED_P0=table0[i];
  229.                         LED_P2=table0[i];
  230.                         LED_P1=table0[i];
  231.                         LED_P3=table0[i];
  232.                         Display(100);
  233.                 }
  234.                 LED_P0=0xff; LED_P2=0xff; LED_P1=0xff; LED_P3=0xff;
  235.                 for(i=0;i<8;i++)
  236.                 {
  237.                         LED_P0=table0[i];
  238.                         LED_P2=table0[i];
  239.                         LED_P1=table0[i];
  240.                         LED_P3=table0[i];
  241.                         Display(100);
  242.                 }
  243.                 LED_P0=0xff; LED_P2=0xff; LED_P1=0xff; LED_P3=0xff;
  244.         }
  245. }

  246. //状态9 间断8格的4个LED亮,然后逆时针逐渐点亮(直到全部点亮)
  247. void disp9()                       
  248. {
  249.         for(i=0;i<8;i++)
  250.         {
  251.                 LED_P0=table2[i];
  252.                 LED_P2=table2[i];
  253.                 LED_P1=table2[i];
  254.                 LED_P3=table2[i];
  255.                 Display(100);
  256.         }
  257.         Display(500);       
  258. }

  259. //状态10 从LED全部亮到全不亮(间断8格的4个LED开始逆时针熄灭)
  260. void disp10()                       
  261. {
  262.         for(i=0;i<9;i++)
  263.         {
  264.                 LED_P0=table4[i];
  265.                 LED_P2=table4[i];
  266.                 LED_P1=table4[i];
  267.                 LED_P3=table4[i];
  268.                 Display(100);
  269.         }
  270.         Display(300);
  271. }

  272. //状态11 间断8格的4个LED亮并顺时针旋转
  273. void disp11()                       
  274. {
  275.         for(j=0;j<2;j++)
  276.         {
  277.                 for(i=0;i<8;i++)
  278.                 {
  279.                         LED_P0=table1[i];
  280.                         LED_P2=table1[i];
  281.                         LED_P1=table1[i];
  282.                         LED_P3=table1[i];
  283.                         Display(100);
  284.                 }
  285.                 LED_P0=0xff; LED_P2=0xff; LED_P1=0xff; LED_P3=0xff;
  286.                 for(i=0;i<8;i++)
  287.                 {
  288.                         LED_P0=table1[i];
  289.                         LED_P2=table1[i];
  290.                         LED_P1=table1[i];
  291.                         LED_P3=table1[i];
  292.                         Display(100);
  293.                 }
  294.                 LED_P0=0xff; LED_P2=0xff; LED_P1=0xff; LED_P3=0xff;
  295.         }
  296. }

  297. //间断8格的4个LED亮,然后顺时针逐渐点亮(直到全部点亮)
  298. void disp12()                       
  299. {
  300.         for(i=0;i<8;i++)
  301.         {
  302.                 LED_P0=table3[i];
  303.                 LED_P2=table3[i];
  304.                 LED_P1=table3[i];
  305.                 LED_P3=table3[i];
  306.                 Display(100);
  307.         }
  308.         Display(1000);
  309. }

  310. //状态13 从LED全部亮到全不亮(间断8格的4个LED开始顺时针熄灭)
  311. void disp13()                       
  312. {
  313.         for(i=0;i<9;i++)
  314.         {
  315.                 LED_P0=table5[i];
  316.                 LED_P2=table5[i];
  317.                 LED_P1=table5[i];
  318.                 LED_P3=table5[i];
  319.                 Display(100);
  320.         }
  321.         Display(300);
  322. }

  323. //状态14 从LED不亮到全亮(从P0.0、P1.0、P2.0、P3.7开始逐步点亮)
  324. void disp14()                       
  325. {
  326.         for(i=0;i<8;i++)
  327.         {
  328.                 LED_P0=table3[i];
  329.                 LED_P1=table2[i];
  330.                 LED_P2=table2[i];
  331.                 LED_P3=table3[i];
  332.                 Display(100);
  333.         }
  334. }

  335. //状态15 从LED全亮到全不亮(从P0.7、P1.7、P2.7、P3.0开始逐步熄灭
  336. void disp15()                       
  337. {
  338.         for(i=0;i<9;i++)
  339.         {
  340.                 LED_P0=table4[i];
  341.                 LED_P1=table5[i];
  342.                 LED_P2=table5[i];
  343.                 LED_P3=table4[i];
  344.                 Display(100);
  345.         }
  346.         Display(300);
  347. }

  348. //状态16 LED灯交替闪烁(频率有慢变快)
  349. void disp16()                       
  350. {
  351.         for(i=0;i<5;i++)
  352.         {
  353.                 LED_P0=0xaa; LED_P1=0xaa; LED_P2=0xaa; LED_P3=0xaa;
  354.                 Display(100);
  355.                 LED_P0=~LED_P0; LED_P1=~LED_P1; LED_P2=~LED_P2; LED_P3=~LED_P3;
  356.                 Display(100);
  357.         }
  358.         for(i=0;i<5;i++)
  359.         {
  360.                 LED_P0=0xaa; LED_P1=0xaa; LED_P2=0xaa; LED_P3=0xaa;
  361.                 Display(200);
  362.                 LED_P0=~LED_P0; LED_P1=~LED_P1; LED_P2=~LED_P2; LED_P3=~LED_P3;
  363.                 Display(200);
  364.         }
  365.         for(i=0;i<5;i++)
  366.         {
  367.                 LED_P0=0xaa; LED_P1=0xaa; LED_P2=0xaa; LED_P3=0xaa;
  368.                 Display(300);
  369.                 LED_P0=~LED_P0; LED_P1=~LED_P1; LED_P2=~LED_P2; LED_P3=~LED_P3;
  370.                 Display(300);
  371.         }
  372.         LED_P0=0xff; LED_P2=0xff; LED_P1=0xff; LED_P3=0xff;
  373.         Display(300);
  374. }

  375. //状态17 LED从P0.7开始逆时针逐步点亮,(循环2次)并且速度会逐步提高
  376. void disp17()                       
  377. {

  378.         for(i=0;i<8;i++)
  379.         {
  380.                 LED_P0=table2[i];
  381.                 Display(100);
  382.         }
  383.         for(i=0;i<8;i++)
  384.         {
  385.                 LED_P1=table2[i];
  386.                 Display(100);
  387.         }       
  388.         for(i=0;i<8;i++)
  389.         {
  390.                 LED_P3=table2[i];
  391.                 Display(100);
  392.         }       
  393.         for(i=0;i<8;i++)
  394.         {
  395.                 LED_P2=table2[i];
  396.                 Display(100);
  397.         }
  398.         LED_P0=0xff; LED_P1=0xff; LED_P3=0xff; LED_P2=0xff;
  399. /*******************************/
  400.         for(i=0;i<8;i++)
  401.         {
  402.                 LED_P0=table2[i];
  403.                 Display(50);
  404.         }
  405.         for(i=0;i<8;i++)
  406.         {
  407.                 LED_P1=table2[i];
  408.                 Display(50);
  409.         }       
  410.         for(i=0;i<8;i++)
  411.         {
  412.                 LED_P3=table2[i];
  413.                 Display(50);
  414.         }       
  415.         for(i=0;i<8;i++)
  416.         {
  417.                 LED_P2=table2[i];
  418.                 Display(50);
  419.         }
  420.         LED_P0=0xff; LED_P1=0xff; LED_P3=0xff; LED_P2=0xff;       
  421. }

  422. //状态18 LED从P0.7开始逆时针逐步点亮(每亮8位后就熄灭)
  423. void disp18()                       
  424. {
  425.         for(i=0;i<8;i++)
  426.         {
  427.                 LED_P0=table2[i];
  428.                 Display(100);
  429.         }
  430.         LED_P0=0xff;
  431.         for(i=0;i<8;i++)
  432.         {
  433.                 LED_P1=table2[i];
  434.                 Display(100);
  435.         }       
  436.         LED_P1=0xff;
  437.         for(i=0;i<8;i++)
  438.         {
  439.                 LED_P3=table2[i];
  440.                 Display(100);
  441.         }
  442.         LED_P3=0xff;       
  443.         for(i=0;i<8;i++)
  444.         {
  445.                 LED_P2=table2[i];
  446.                 Display(100);
  447.         }
  448.         LED_P2=0xff;       
  449. }

  450. //状态19 LED从P2.7开始顺时针逐步点亮,(循环2次)并且速度会逐步提高
  451. void disp19()                       
  452. {
  453.         for(i=0;i<8;i++)
  454.         {
  455.                 LED_P2=table3[i];
  456.                 Display(100);
  457.         }
  458.         for(i=0;i<8;i++)
  459.         {
  460.                 LED_P3=table3[i];
  461.                 Display(100);
  462.         }       
  463.         for(i=0;i<8;i++)
  464.         {
  465.                 LED_P1=table3[i];
  466.                 Display(100);
  467.         }       
  468.         for(i=0;i<8;i++)
  469.         {
  470.                 LED_P0=table3[i];
  471.                 Display(100);
  472.         }
  473.         LED_P0=0xff; LED_P1=0xff; LED_P3=0xff; LED_P2=0xff;
  474. /*******************************/
  475.         for(i=0;i<8;i++)
  476.         {
  477.                 LED_P2=table3[i];
  478.                 Display(50);
  479.         }
  480.         for(i=0;i<8;i++)
  481.         {
  482.                 LED_P3=table3[i];
  483.                 Display(50);
  484.         }       
  485.         for(i=0;i<8;i++)
  486.         {
  487.                 LED_P1=table3[i];
  488.                 Display(50);
  489.         }       
  490.         for(i=0;i<8;i++)
  491.         {
  492.                 LED_P0=table3[i];
  493.                 Display(50);
  494.         }
  495.         LED_P0=0xff; LED_P1=0xff; LED_P3=0xff; LED_P2=0xff;       
  496. }

  497. //状态20 LED从P2.7开始顺时针逐步点亮(每亮8位后就熄灭)
  498. void disp20()                       
  499. {
  500.         for(i=0;i<8;i++)
  501.         {
  502.                 LED_P2=table3[i];
  503.                 Display(100);
  504.         }
  505.         LED_P2=0xff;
  506.         for(i=0;i<8;i++)
  507.         {
  508.                 LED_P3=table3[i];
  509.                 Display(100);
  510.         }       
  511.         LED_P3=0xff;
  512.         for(i=0;i<8;i++)
  513.         {
  514.                 LED_P1=table3[i];
  515.                 Display(100);
  516.         }
  517.         LED_P1=0xff;       
  518.         for(i=0;i<8;i++)
  519.         {
  520.                 LED_P0=table3[i];
  521.                 Display(100);
  522.         }
  523.         LED_P0=0xff;               
  524. }

  525. //状态21 2个LED开始上下移动半圈
  526. void disp21()                       
  527. {
  528.         for(i=0;i<8;i++)
  529.         {
  530.                 LED_P0=table0[i];
  531.                 LED_P2=table1[i];
  532.                 Display(100);
  533.         }
  534.         LED_P0=0xff; LED_P2=0xff;
  535.         for(i=0;i<8;i++)
  536.         {
  537.                 LED_P1=table0[i];
  538.                 LED_P3=table1[i];
  539.                 Display(100);
  540.         }
  541.        
  542.         for(i=0;i<8;i++)
  543.         {
  544.                 LED_P1=table1[i];
  545.                 LED_P3=table0[i];
  546.                 Display(100);
  547.         }
  548.         LED_P1=0xff; LED_P3=0xff;
  549.         for(i=0;i<8;i++)
  550.         {
  551.                 LED_P0=table1[i];
  552.                 LED_P2=table0[i];
  553.                 Display(100);
  554.         }
  555. }

  556. //装态22 2个LED自上而下移动(循环5次,且频率渐快,到最快时持续循环16次,然后循环5次频率再逐渐降低)
  557. void disp22()                       
  558. {       
  559.         for(j=0;j<5;j++)
  560.         {
  561.                 for(i=0;i<8;i++)
  562.                 {
  563.                         LED_P0=table0[i];
  564.                         LED_P2=table1[i];
  565.                         Display(tt);
  566.                 }
  567.                 LED_P0=0xff; LED_P2=0xff;
  568.                 for(i=0;i<8;i++)
  569.                 {
  570.                         LED_P1=table0[i];
  571.                         LED_P3=table1[i];
  572.                         Display(tt);
  573.                 }
  574.                 LED_P1=0xff; LED_P3=0xff;
  575.                 tt=tt-10;
  576.         }

  577.         for(j=0;j<16;j++)
  578.         {
  579.                 for(i=0;i<8;i++)
  580.                 {
  581.                         LED_P0=table0[i];
  582.                         LED_P2=table1[i];
  583.                         Display(20);
  584.                 }
  585.                 LED_P0=0xff; LED_P2=0xff;
  586.                 for(i=0;i<8;i++)
  587.                 {
  588.                         LED_P1=table0[i];
  589.                         LED_P3=table1[i];
  590.                         Display(20);
  591.                 }
  592.                 LED_P1=0xff; LED_P3=0xff;
  593.         }
  594.         tt=20;
  595.         for(j=0;j<5;j++)
  596.         {
  597.                 for(i=0;i<8;i++)
  598.                 {
  599.                         LED_P0=table0[i];
  600.                         LED_P2=table1[i];
  601.                         Display(tt);
  602.                 }
  603.                 LED_P0=0xff; LED_P2=0xff;
  604.                 for(i=0;i<8;i++)
  605.                 {
  606.                         LED_P1=table0[i];
  607.                         LED_P3=table1[i];
  608.                         Display(tt);
  609.                 }
  610.                 LED_P1=0xff; LED_P3=0xff;
  611.                 tt=tt+10;
  612.         }
  613.         tt=70;       
  614.                
  615. }

  616. //状态23 LED上下交替闪烁
  617. void disp23()                       
  618. {

  619.         for(i=0;i<2;i++)
  620.         {
  621.                 LED_P0=0x00; LED_P2=0x00;
  622.                 Display(1000);
  623.                 LED_P0=0xff; LED_P2=0xff;
  624.                 LED_P1=0x00; LED_P3=0x00;
  625.                 Display(1000);
  626.                 LED_P1=0xff; LED_P3=0xff;
  627.         }
  628. }

  629. //状态24 LED左右交替闪烁
  630. void disp24()                       
  631. {       
  632.         LED_P1=0xff; LED_P3=0xff; LED_P0=0xff; LED_P2=0xff;
  633.         for(i=0;i<2;i++)
  634.         {
  635.                 LED_P0=0x00; LED_P1=0x00;
  636.                 Display(1000);
  637.                 LED_P0=0xff; LED_P1=0xff;
  638.                 LED_P2=0x00; LED_P3=0x00;
  639.                 Display(1000);
  640.                 LED_P2=0xff; LED_P3=0xff;
  641.         }
  642. }

  643. //状态25 LED交替闪烁
  644. void disp25()                       
  645. {
  646.         for(i=0;i<5;i++)
  647.         {
  648.                 LED_P0=0xaa; LED_P1=0xaa; LED_P2=0xaa; LED_P3=0xaa;
  649.                 Display(1000);
  650.                 LED_P0=~LED_P0; LED_P1=~LED_P1; LED_P2=~LED_P2; LED_P3=~LED_P3;
  651.                 Display(1000);               
  652.         }
  653. }

  654. //状态26 2个LED开始上下移动半圈(LED不亮流水)
  655. void disp26()                       
  656. {
  657.         LED_P0=0x00;LED_P1=0x00;LED_P2=0x00;LED_P3=0x00;
  658.         for(i=0;i<8;i++)
  659.         {
  660.                 LED_P0=~table0[i];
  661.                 LED_P2=~table1[i];
  662.                 Display(200);
  663.         }
  664.         LED_P0=0x00; LED_P2=0x00;
  665.         for(i=0;i<8;i++)
  666.         {
  667.                 LED_P1=~table0[i];
  668.                 LED_P3=~table1[i];
  669.                 Display(200);
  670.         }
  671.        
  672.         for(i=0;i<8;i++)
  673.         {
  674.                 LED_P1=~table1[i];
  675.                 LED_P3=~table0[i];
  676.                 Display(200);
  677.         }
  678.         LED_P1=0x00; LED_P3=0x00;
  679.         for(i=0;i<8;i++)
  680.         {
  681.                 LED_P0=~table1[i];
  682.                 LED_P2=~table0[i];
  683.                 Display(200);
  684.         }
  685. }

  686. //状态27 逐步顺时针点亮P2、P1的LED,熄灭后,再顺时针点亮P0、P3的LED
  687. void disp27()                       
  688. {
  689.         LED_P0=0xff; LED_P1=0xff; LED_P2=0xff; LED_P3=0xff;
  690.         for(j=0;j<2;j++)
  691.         {
  692.                 for(i=0;i<8;i++)
  693.                 {
  694.                         LED_P2=table3[i];
  695.                         LED_P1=table3[i];
  696.                         Display(100);
  697.                 }
  698.                 LED_P2=0xff; LED_P1=0xff;
  699.                 for(i=0;i<8;i++)
  700.                 {
  701.                         LED_P0=table3[i];
  702.                         LED_P3=table3[i];
  703.                         Display(100);
  704.                 }
  705.                 LED_P0=0xff; LED_P3=0xff;
  706.         }
  707. }
  708.                
  709. //状态28 P1、P2和P0、P3交替闪烁               
  710. void disp28()                       
  711. {       
  712.         for(i=0;i<2;i++)
  713.         {
  714.                 LED_P1=0x00; LED_P2=0x00; LED_P0=0xff; LED_P3=0xff;
  715.                 Display(1000);
  716.                 LED_P1=0xff; LED_P2=0xff; LED_P0=0x00; LED_P3=0x00;
  717.                 Display(1000);
  718.         }
  719.         LED_P1=0xff; LED_P2=0xff; LED_P0=0xff; LED_P3=0xff;
  720. }

  721. //状态29 逐步顺时针点亮P2、P1的LED,再顺时熄灭后,再顺时针点亮P0、P3的LED,再顺时熄灭
  722. void disp29()                       
  723. {       

  724.         LED_P0=0xff; LED_P1=0xff; LED_P2=0xff; LED_P3=0xff;
  725.         for(j=0;j<2;j++)
  726.         {
  727.                 for(i=0;i<8;i++)
  728.                 {
  729.                         LED_P2=table3[i];
  730.                         LED_P1=table3[i];
  731.                         Display(100);
  732.                 }
  733.                 for(i=0;i<9;i++)
  734.                 {
  735.                         LED_P2=table5[i];
  736.                         LED_P1=table5[i];
  737.                         Display(100);
  738.                 }
  739.                 for(i=0;i<8;i++)
  740.                 {
  741.                         LED_P0=table3[i];
  742.                         LED_P3=table3[i];
  743.                         Display(100);
  744.                 }
  745.                 for(i=0;i<9;i++)
  746.                 {
  747.                         LED_P0=table5[i];
  748.                         LED_P3=table5[i];
  749.                         Display(100);
  750.                 }
  751.         }
  752.         Display(200);       
  753. }

  754. //状态30 逐步逆时针点亮P2、P1的LED,熄灭后,再逆时针点亮P0、P3的LED
  755. void disp30()               
  756. {
  757.         LED_P0=0xff; LED_P1=0xff; LED_P2=0xff; LED_P3=0xff;
  758.         for(j=0;j<2;j++)
  759.         {
  760.                 for(i=0;i<8;i++)
  761.                 {
  762.                         LED_P2=table2[i];
  763.                         LED_P1=table2[i];
  764.                         Display(100);
  765.                 }
  766.                 LED_P2=0xff; LED_P1=0xff;
  767.                 for(i=0;i<8;i++)
  768.                 {
  769.                         LED_P0=table2[i];
  770.                         LED_P3=table2[i];
  771.                         Display(100);
  772.                 }
  773.                 LED_P0=0xff; LED_P3=0xff;
  774.         }
  775. }

  776. //状态31 逐步逆时针点亮P2、P1的LED,再逆时熄灭后,再逆时针点亮P0、P3的LED,再逆时熄灭
  777. void disp31()                       
  778. {
  779.         LED_P0=0xff; LED_P1=0xff; LED_P2=0xff; LED_P3=0xff;
  780.         for(j=0;j<2;j++)
  781.         {
  782.                 for(i=0;i<8;i++)
  783.                 {
  784.                         LED_P2=table2[i];
  785.                         LED_P1=table2[i];
  786.                         Display(100);
  787.                 }
  788.                 for(i=0;i<9;i++)
  789.                 {
  790.                         LED_P2=table4[i];
  791.                         LED_P1=table4[i];
  792.                         Display(100);
  793.                 }
  794.                 for(i=0;i<8;i++)
  795.                 {
  796.                         LED_P0=table2[i];
  797.                         LED_P3=table2[i];
  798.                         Display(100);
  799.                 }
  800.                 for(i=0;i<9;i++)
  801.                 {
  802.                         LED_P0=table4[i];
  803.                         LED_P3=table4[i];
  804.                         Display(100);
  805.                 }
  806.         }
  807.         Display(200);       
  808. }

  809. //状态32 LED自上而下逐步点亮,然后从下往上逐步熄灭
  810. void disp32()                       
  811. {
  812.         for(i=0;i<8;i++)
  813.         {
  814.                 LED_P0=table2[i];
  815.                 LED_P2=table3[i];
  816.                 Display(100);
  817.         }
  818.         for(i=0;i<8;i++)
  819.         {
  820.                 LED_P1=table2[i];
  821.                 LED_P3=table3[i];
  822.                 Display(100);
  823.         }
  824.         for(i=0;i<9;i++)
  825.         {
  826.                 LED_P1=table5[i];
  827.                 LED_P3=table4[i];
  828.                 Display(100);
  829.         }
  830.         for(i=0;i<9;i++)
  831.         {
  832.                 LED_P0=table5[i];
  833.                 LED_P2=table4[i];
  834.                 Display(100);
  835.         }
  836. }

  837. //状态33 LED从左往右开始点亮(直到全亮),然后从左右两边开始熄灭(直到全部熄灭)
  838. void disp33()                       
  839. {
  840.         for(i=0;i<8;i++)
  841.         {
  842.                 LED_P0=table3[i];
  843.                 LED_P1=table2[i];
  844.                 Display(100);
  845.         }
  846.         for(i=0;i<8;i++)
  847.         {
  848.                 LED_P2=table3[i];
  849.                 LED_P3=table2[i];
  850.                 Display(100);
  851.         }
  852.         Display(500);
  853.         for(i=0;i<9;i++)
  854.         {
  855.                 LED_P2=table4[i];
  856.                 LED_P3=table5[i];
  857.                 LED_P1=table4[i];
  858.                 LED_P0=table5[i];
  859.                 Display(100);
  860.         }
  861.         Display(300);
  862. }

  863. //状态34 LED从左往右开始点亮(直到全亮),然后从中间往左右边熄灭
  864. void disp34()                       
  865. {
  866.         for(i=0;i<8;i++)
  867.         {
  868.                 LED_P2=table2[i];
  869.                 LED_P3=table3[i];
  870.                 Display(100);
  871.         }
  872.         for(i=0;i<8;i++)
  873.         {
  874.                 LED_P0=table2[i];
  875.                 LED_P1=table3[i];
  876.                 Display(100);
  877.         }
  878.         Display(500);
  879.         for(i=0;i<9;i++)
  880.         {
  881.                 LED_P2=table5[i];
  882.                 LED_P3=table4[i];
  883.                 LED_P1=table5[i];
  884.                 LED_P0=table4[i];
  885.                 Display(100);
  886.         }
  887.         Display(300);       
  888. }

  889. //状态35  从P2.7、P1.7开始同时顺时针旋转,直到LED全亮
  890. void disp35()                       
  891. {
  892.         for(i=0;i<8;i++)
  893.         {
  894.                 LED_P2=table3[i];
  895.                 LED_P1=table3[i];
  896.                 Display(100);
  897.         }
  898.         for(i=0;i<8;i++)
  899.         {
  900.                 LED_P3=table3[i];
  901.                 LED_P0=table3[i];
  902.                 Display(100);
  903.         }
  904. }

  905. //状态36  从P0.7、P3.1开始同时逆时针旋转,直到LED全亮
  906. void disp36()                       
  907. {
  908.         for(i=0;i<8;i++)
  909.         {
  910.                 LED_P0=table2[i];
  911.                 LED_P3=table2[i];
  912.                 Display(100);
  913.         }
  914.         for(i=0;i<8;i++)
  915.         {
  916.                 LED_P1=table2[i];
  917.                 LED_P2=table2[i];
  918.                 Display(100);
  919.         }
  920. }

  921. //状态37 2个LED自上而下移动,并点亮最下2个LED,然后2个LED再自下而上回去,同时4个LED(上下各2个LED)再来回移动一次
  922. void disp37()                       
  923. {
  924.         for(i=0;i<8;i++)
  925.         {
  926.                 LED_P0=table0[i];
  927.                 LED_P2=table1[i];
  928.                 Display(100);
  929.         }
  930.         LED_P0=0xff; LED_P2=0xff;
  931.         for(i=0;i<8;i++)
  932.         {
  933.                 LED_P1=table0[i];
  934.                 LED_P3=table1[i];
  935.                 Display(100);
  936.         }
  937.        
  938.         for(i=0;i<8;i++)
  939.         {
  940.                 LED_P1=table7[i];
  941.                 LED_P3=table6[i];
  942.                 Display(100);
  943.         }
  944.         LED_P1=0x7f; LED_P3=0xfe;
  945.         for(i=0;i<8;i++)
  946.         {
  947.                 LED_P0=table1[i];
  948.                 LED_P2=table0[i];
  949.                 Display(100);
  950.         }
  951.        
  952.         for(i=0;i<8;i++)
  953.         {
  954.                 LED_P0=table0[i];
  955.                 LED_P2=table1[i];
  956.                 LED_P1=table1[i];
  957.                 LED_P3=table0[i];
  958.                 Display(200);
  959.         }
  960.        
  961.         for(i=0;i<8;i++)
  962.         {
  963.                 LED_P0=table1[i];
  964.                 LED_P1=table0[i];
  965.                 LED_P2=table0[i];
  966.                 LED_P3=table1[i];
  967.                 Display(200);
  968.         }       
  969.         LED_P0=0xff;LED_P1=0xff; LED_P2=0xff;LED_P3=0xff;
  970. }

  971. //状态38 逐步顺时针点亮P2、P1的LED,熄灭后,再顺时针点亮P0、P3的LED
  972. void disp38()                       
  973. {
  974.         LED_P0=0xff; LED_P1=0xff; LED_P2=0xff; LED_P3=0xff;
  975.         for(j=0;j<2;j++)
  976.         {
  977.                 for(i=0;i<8;i++)
  978.                 {
  979.                         LED_P2=table3[i];
  980.                         LED_P1=table3[i];
  981.                         Display(100);
  982.                 }
  983.                 LED_P2=0xff; LED_P1=0xff;
  984.                 for(i=0;i<8;i++)
  985.                 {
  986.                         LED_P0=table3[i];
  987.                         LED_P3=table3[i];
  988.                         Display(100);
  989.                 }
  990.                 LED_P0=0xff; LED_P3=0xff;
  991.         }       
  992. }

  993. //状态39 P1、P3LED(下半部分)一直亮,上半部分LED向外扩张亮,然后闪烁3次
  994. void disp39()                       
  995. {
  996.         LED_P1=0x00; LED_P3=0x00;
  997. ……………………

  998. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
心形花样流水灯.zip (408.8 KB, 下载次数: 32)


评分

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

查看全部评分

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

使用道具 举报

沙发
ID:207455 发表于 2017-6-3 19:29 来自手机 | 只看该作者
学习用用,感谢你
回复

使用道具 举报

板凳
ID:89286 发表于 2018-10-18 20:07 | 只看该作者
thanks for sharing
回复

使用道具 举报

地板
ID:412076 发表于 2018-10-19 08:40 | 只看该作者
发现新大陆,感谢感谢。
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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