找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 7747|回复: 1
收起左侧

单片机七彩炫光爱心花样灯程序代码

[复制链接]
ID:76127 发表于 2015-4-17 21:05 | 显示全部楼层 |阅读模式
  1. //姬家寨电子科技实验室 程序编写:姬学瑞 版权所有,侵权必究   !
  2. #include <REGX52.H>
  3. #define uint unsigned int
  4. #define uchar unsigned char
  5. uchar code table0[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};//LED从低位往高位移
  6. uchar code table1[]={0x7f,0xbf,0xdf,0xef,0xf7,0xfb,0xfd,0xfe};//LED从高位往低位移
  7. uchar code table2[]={0xfe,0xfc,0xf8,0xf0,0xe0,0xc0,0x80,0x00};//LED从1个亮到8个都点亮(从低位往高位)
  8. uchar code table3[]={0x7f,0x3f,0x1f,0x0f,0x07,0x03,0x01,0x00};//LED从1个亮到8个都点亮(从高位往低位)
  9. uchar code table4[]={0x00,0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f,0xff};//LED从8个全亮到一个都不亮(从低位往高位)
  10. uchar code table5[]={0x00,0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff};//LED从8个全亮到一个都不亮(从高位往低位)
  11. uchar code table6[]={0xfe,0xfc,0xfa,0xf6,0xee,0xde,0xbe,0x7e};//LED从低位往高位移(最低位始终为0)
  12. uchar code table7[]={0x7f,0x3f,0x5f,0x6f,0x77,0x7b,0x7d,0x7e};//LED从高位往低位移(最高位始终为0)
  13. uchar i,j;  //定义循环变量
  14. uint tt=70;  //定义时间指数
  15. void delay(uint time) //延时函数
  16. {
  17. uint x,y;
  18. for(x=time;x>0;x--)
  19. for(y=110;y>0;y--);
  20. }
  21. void disp0()   //状态0 所有LED闪烁3次
  22. {
  23. for(i=0;i<3;i++)
  24. {
  25.   P0=0x00; P2=0x00; P3=0x00; P1=0x00;
  26.   delay(300);
  27.   P0=0xff; P2=0xff; P3=0xff; P1=0xff;
  28.   delay(300);
  29. }
  30. }
  31. void disp1()   //状态1 LED顺时针转一圈
  32. {
  33. for(i=0;i<8;i++)
  34. {
  35.   P2=table1[i];
  36.   delay(100);
  37. }
  38. P2=0xff;
  39. for(i=0;i<8;i++)
  40. {
  41.   P3=table1[i];
  42.   delay(100);
  43. }
  44. P3=0xff;
  45. for(i=0;i<8;i++)
  46. {
  47.   P1=table1[i];      
  48.   delay(100);
  49. }
  50. P1=0xff;
  51. for(i=0;i<8;i++)
  52. {
  53.   P0=table0[i];
  54.   delay(100);
  55. }
  56. P0=0xff;
  57. }
  58. void disp2()   //状态2 LED逆时针转一圈
  59. {
  60. for(i=0;i<8;i++)
  61. {
  62.   P0=table1[i];
  63.   delay(100);
  64. }
  65. P0=0xff;
  66. for(i=0;i<8;i++)
  67. {
  68.   P1=table0[i];
  69.   delay(100);
  70. }
  71. P1=0xff;
  72. for(i=0;i<8;i++)
  73. {
  74.   P3=table0[i];
  75.   delay(100);
  76. }
  77. P3=0xff;
  78. for(i=0;i<8;i++)
  79. {
  80.   P2=table0[i];
  81.   delay(100);
  82. }
  83. P2=0xff;
  84. }
  85. void disp3()   //状态3 4个LED同时顺时、逆时针移动1/4圈
  86. {
  87. for(i=0;i<8;i++)
  88. {
  89.   P0=table1[i];
  90.   P1=table1[i];
  91.   P2=table1[i];
  92.   P3=table0[i];
  93.   delay(100);
  94. }
  95. for(i=0;i<8;i++)
  96. {
  97.   P0=table0[i];
  98.   P1=table0[i];
  99.   P2=table0[i];
  100.   P3=table1[i];
  101.   delay(100);
  102. }
  103. P3=0xff; P0=0xff;
  104. }
  105. void disp4()   //状态4  2个LED同时顺时针移动半圈
  106. {
  107. for(i=0;i<8;i++)
  108. {
  109.   P2=table1[i];
  110.   P1=table1[i];
  111.   delay(100);
  112. }
  113. P2=0xff; P1=0xff;
  114. for(i=0;i<8;i++)
  115. {
  116.   P3=table1[i];
  117.   P0=table0[i];
  118.   delay(100);
  119. }
  120. P3=0xff; P0=0xff;
  121. }
  122. void disp5()   //状态5  2个LED同时逆时针移动半圈
  123. {
  124. for(i=0;i<8;i++)
  125. {
  126.   P0=table1[i];
  127.   P3=table0[i];
  128.   delay(100);
  129. }
  130. P0=0xff; P3=0xff;
  131. for(i=0;i<8;i++)
  132. {
  133.   P1=table0[i];
  134.   P2=table0[i];
  135.   delay(100);
  136. }
  137. P1=0xff; P2=0xff;
  138. }
  139. void disp6()   //状态6 LED自上而下逐渐点亮(一半点亮一半不亮)
  140. {
  141. for(i=0;i<8;i++)
  142. {
  143.   P0=table3[i];
  144.   P2=table3[i];
  145.   delay(100);
  146. }
  147. P0=0xff; P2=0xff;
  148. for(i=0;i<8;i++)
  149. {
  150.   P1=table2[i];
  151.   P3=table3[i];
  152.   delay(100);
  153. }
  154. P1=0xff; P3=0xff;
  155. }
  156. void disp7()   //状态7 LED自下而上逐渐点亮(直到全部点亮)
  157. {
  158. for(i=0;i<8;i++)
  159. {
  160.   P1=table3[i];
  161.   P3=table2[i];
  162.   delay(100);
  163. }
  164. for(i=0;i<8;i++)
  165. {
  166.   P0=table2[i];
  167.   P2=table2[i];
  168.   delay(100);
  169. }
  170. }
  171. void disp8()   //状态8 间断8格的4个LED亮并逆时针旋转
  172. {
  173. for(j=0;j<2;j++)
  174. {
  175.   for(i=0;i<8;i++)
  176.   {
  177.    P0=table1[i];
  178.    P2=table0[i];
  179.    P1=table0[i];
  180.    P3=table0[i];
  181.    delay(100);
  182.   }
  183.   P0=0xff; P2=0xff; P1=0xff; P3=0xff;
  184.   for(i=0;i<8;i++)
  185.   {
  186.    P0=table1[i];
  187.    P2=table0[i];
  188.    P1=table0[i];
  189.    P3=table0[i];
  190.    delay(100);
  191.   }
  192.   P0=0xff; P2=0xff; P1=0xff; P3=0xff;
  193. }
  194. }
  195. void disp9()   //状态9 间断8格的4个LED亮,然后逆时针逐渐点亮(直到全部点亮)
  196. {
  197. for(i=0;i<8;i++)
  198. {
  199.   P0=table3[i];
  200.   P2=table2[i];
  201.   P1=table2[i];
  202.   P3=table2[i];
  203.   delay(100);
  204. }
  205. delay(500);
  206. }
  207. void disp10()   //状态10 从LED全部亮到全不亮(间断8格的4个LED开始逆时针熄灭)
  208. {
  209. for(i=0;i<9;i++)
  210. {
  211.   P0=table5[i];
  212.   P2=table4[i];
  213.   P1=table4[i];
  214.   P3=table4[i];
  215.   delay(100);
  216. }
  217. delay(300);
  218. }
  219. void disp11()   //状态11 间断8格的4个LED亮并顺时针旋转
  220. {
  221. for(j=0;j<2;j++)
  222. {
  223.   for(i=0;i<8;i++)
  224.   {
  225.    P0=table0[i];
  226.    P2=table1[i];
  227.    P1=table1[i];
  228.    P3=table1[i];
  229.    delay(100);
  230.   }
  231.   P0=0xff; P2=0xff; P1=0xff; P3=0xff;
  232.   for(i=0;i<8;i++)
  233.   {
  234.    P0=table0[i];
  235.    P2=table1[i];
  236.    P1=table1[i];
  237.    P3=table1[i];
  238.    delay(100);
  239.   }
  240.   P0=0xff; P2=0xff; P1=0xff; P3=0xff;
  241. }
  242. }
  243. void disp12()   //间断8格的4个LED亮,然后顺时针逐渐点亮(直到全部点亮)
  244. {
  245. for(i=0;i<8;i++)
  246. {
  247.   P0=table2[i];
  248.   P2=table3[i];
  249.   P1=table3[i];
  250.   P3=table3[i];
  251.   delay(100);
  252. }
  253. delay(1000);
  254. }
  255. void disp13()   //状态13 从LED全部亮到全不亮(间断8格的4个LED开始顺时针熄灭)
  256. {
  257. for(i=0;i<9;i++)
  258. {
  259.   P0=table4[i];
  260.   P2=table5[i];
  261.   P1=table5[i];
  262.   P3=table5[i];
  263.   delay(100);
  264. }
  265. delay(300);
  266. }
  267. void disp14()   //状态14 从LED不亮到全亮(从P0.0、P1.0、P2.0、P3.7开始逐步点亮)
  268. {
  269. for(i=0;i<8;i++)
  270. {
  271.   P0=table2[i];
  272.   P1=table2[i];
  273.   P2=table2[i];
  274.   P3=table3[i];
  275.   delay(100);
  276. }
  277. }
  278. void disp15()   //状态15 从LED全亮到全不亮(从P0.7、P1.7、P2.7、P3.0开始逐步熄灭)
  279. {
  280. for(i=0;i<9;i++)
  281. {
  282.   P0=table5[i];
  283.   P1=table5[i];
  284.   P2=table5[i];
  285.   P3=table4[i];
  286.   delay(100);
  287. }
  288. delay(300);
  289. }
  290. void disp16()   //状态16 LED灯交替闪烁(频率有慢变快)
  291. {
  292. for(i=0;i<5;i++)
  293. {
  294.   P0=0xaa; P1=0xaa; P2=0xaa; P3=0xaa;
  295.   delay(100);
  296.   P0=~P0; P1=~P1; P2=~P2; P3=~P3;
  297.   delay(100);
  298. }
  299. for(i=0;i<5;i++)
  300. {
  301.   P0=0xaa; P1=0xaa; P2=0xaa; P3=0xaa;
  302.   delay(200);
  303.   P0=~P0; P1=~P1; P2=~P2; P3=~P3;
  304.   delay(200);
  305. }
  306. for(i=0;i<5;i++)
  307. {
  308.   P0=0xaa; P1=0xaa; P2=0xaa; P3=0xaa;
  309.   delay(300);
  310.   P0=~P0; P1=~P1; P2=~P2; P3=~P3;
  311.   delay(300);
  312. }
  313. P0=0xff; P2=0xff; P1=0xff; P3=0xff;
  314. delay(300);
  315. }
  316. void disp17()   //状态17 LED从P0.7开始逆时针逐步点亮,(循环2次)并且速度会逐步提高
  317. {
  318. for(i=0;i<8;i++)
  319. {
  320.   P0=table3[i];
  321.   delay(100);
  322. }
  323. for(i=0;i<8;i++)
  324. {
  325.   P1=table2[i];
  326.   delay(100);
  327. }
  328. for(i=0;i<8;i++)
  329. {
  330.   P3=table2[i];
  331.   delay(100);
  332. }
  333. for(i=0;i<8;i++)
  334. {
  335.   P2=table2[i];
  336.   delay(100);
  337. }
  338. P0=0xff; P1=0xff; P3=0xff; P2=0xff;
  339. /*******************************/
  340. for(i=0;i<8;i++)
  341. {
  342.   P0=table3[i];
  343.   delay(50);
  344. }
  345. for(i=0;i<8;i++)
  346. {
  347.   P1=table2[i];
  348.   delay(50);
  349. }
  350. for(i=0;i<8;i++)
  351. {
  352.   P3=table2[i];
  353.   delay(50);
  354. }
  355. for(i=0;i<8;i++)
  356. {
  357.   P2=table2[i];
  358.   delay(50);
  359. }
  360. P0=0xff; P1=0xff; P3=0xff; P2=0xff;
  361. }
  362. void disp18()   //状态18 LED从P0.7开始逆时针逐步点亮(每亮8位后就熄灭)
  363. {
  364. for(i=0;i<8;i++)
  365. {
  366.   P0=table3[i];
  367.   delay(100);
  368. }
  369. P0=0xff;
  370. for(i=0;i<8;i++)
  371. {
  372.   P1=table2[i];
  373.   delay(100);
  374. }
  375. P1=0xff;
  376. for(i=0;i<8;i++)
  377. {
  378.   P3=table2[i];
  379.   delay(100);
  380. }
  381. P3=0xff;
  382. for(i=0;i<8;i++)
  383. {
  384.   P2=table2[i];
  385.   delay(100);
  386. }
  387. P2=0xff;
  388. }
  389. void disp19()   //状态19 LED从P2.7开始顺时针逐步点亮,(循环2次)并且速度会逐步提高
  390. {
  391. for(i=0;i<8;i++)
  392. {
  393.   P2=table3[i];
  394.   delay(100);
  395. }
  396. for(i=0;i<8;i++)
  397. {
  398.   P3=table3[i];
  399.   delay(100);
  400. }
  401. for(i=0;i<8;i++)
  402. {
  403.   P1=table3[i];
  404.   delay(100);
  405. }
  406. for(i=0;i<8;i++)
  407. {
  408.   P0=table2[i];
  409.   delay(100);
  410. }
  411. P0=0xff; P1=0xff; P3=0xff; P2=0xff;
  412. /*******************************/
  413. for(i=0;i<8;i++)
  414. {
  415.   P2=table3[i];
  416.   delay(50);
  417. }
  418. for(i=0;i<8;i++)
  419. {
  420.   P3=table3[i];
  421.   delay(50);
  422. }
  423. for(i=0;i<8;i++)
  424. {
  425.   P1=table3[i];
  426.   delay(50);
  427. }
  428. for(i=0;i<8;i++)
  429. {
  430.   P0=table2[i];
  431.   delay(50);
  432. }
  433. P0=0xff; P1=0xff; P3=0xff; P2=0xff;
  434. }
  435. void disp20()   //状态20 LED从P2.7开始顺时针逐步点亮(每亮8位后就熄灭)
  436. {
  437. for(i=0;i<8;i++)
  438. {
  439.   P2=table3[i];
  440.   delay(100);
  441. }
  442. P2=0xff;
  443. for(i=0;i<8;i++)
  444. {
  445.   P3=table3[i];
  446.   delay(100);
  447. }
  448. P3=0xff;
  449. for(i=0;i<8;i++)
  450. {
  451.   P1=table3[i];
  452.   delay(100);
  453. }
  454. P1=0xff;
  455. for(i=0;i<8;i++)
  456. {
  457.   P0=table2[i];
  458.   delay(100);
  459. }
  460. P0=0xff;  
  461. }
  462. void disp21()   //状态21 2个LED开始上下移动半圈
  463. {
  464. for(i=0;i<8;i++)
  465. {
  466.   P0=table1[i];
  467.   P2=table1[i];
  468.   delay(100);
  469. }
  470. P0=0xff; P2=0xff;
  471. for(i=0;i<8;i++)
  472. {
  473.   P1=table0[i];
  474.   P3=table1[i];
  475.   delay(100);
  476. }

  477. for(i=0;i<8;i++)
  478. {
  479.   P1=table1[i];
  480.   P3=table0[i];
  481.   delay(100);
  482. }
  483. P1=0xff; P3=0xff;
  484. for(i=0;i<8;i++)
  485. {
  486.   P0=table0[i];
  487.   P2=table0[i];
  488.   delay(100);
  489. }
  490. }
  491. void disp22()   //装态22 2个LED自上而下移动(循环5次,且频率渐快,到最快时持续循环16次,然后循环5次频率再逐渐降低)
  492. {
  493. for(j=0;j<5;j++)
  494. {
  495.   for(i=0;i<8;i++)
  496.   {
  497.    P0=table1[i];
  498.    P2=table1[i];
  499.    delay(tt);
  500.   }
  501.   P0=0xff; P2=0xff;
  502.   for(i=0;i<8;i++)
  503.   {
  504.    P1=table0[i];
  505.    P3=table1[i];
  506.    delay(tt);
  507.   }
  508.   P1=0xff; P3=0xff;
  509.   tt=tt-10;
  510. }
  511. for(j=0;j<16;j++)
  512. {
  513.   for(i=0;i<8;i++)
  514.   {
  515.    P0=table1[i];
  516.    P2=table1[i];
  517.    delay(20);
  518.   }
  519.   P0=0xff; P2=0xff;
  520.   for(i=0;i<8;i++)
  521.   {
  522.    P1=table0[i];
  523.    P3=table1[i];
  524.    delay(20);
  525.   }
  526.   P1=0xff; P3=0xff;
  527. }
  528. tt=20;
  529. for(j=0;j<5;j++)
  530. {
  531.   for(i=0;i<8;i++)
  532.   {
  533.    P0=table1[i];
  534.    P2=table1[i];
  535.    delay(tt);
  536.   }
  537.   P0=0xff; P2=0xff;
  538.   for(i=0;i<8;i++)
  539.   {
  540.    P1=table0[i];
  541.    P3=table1[i];
  542.    delay(tt);
  543.   }
  544.   P1=0xff; P3=0xff;
  545.   tt=tt+10;
  546. }
  547. tt=70;
  548.   
  549. }
  550. void disp23()   //状态23 LED上下交替闪烁
  551. {
  552. for(i=0;i<2;i++)
  553. {
  554.   P0=0x00; P2=0x00;
  555.   delay(1000);
  556.   P0=0xff; P2=0xff;
  557.   P1=0x00; P3=0x00;
  558.   delay(1000);
  559.   P1=0xff; P3=0xff;
  560. }
  561. }
  562. void disp24()   //状态24 LED左右交替闪烁
  563. {
  564. P1=0xff; P3=0xff; P0=0xff; P2=0xff;
  565. for(i=0;i<2;i++)
  566. {
  567.   P0=0x00; P1=0x00;
  568.   delay(1000);
  569.   P0=0xff; P1=0xff;
  570.   P2=0x00; P3=0x00;
  571.   delay(1000);
  572.   P2=0xff; P3=0xff;
  573. }
  574. }
  575. void disp25()   //状态25 LED交替闪烁
  576. {
  577. for(i=0;i<5;i++)
  578. {
  579.   P0=0xaa; P1=0xaa; P2=0xaa; P3=0xaa;
  580.   delay(1000);
  581.   P0=~P0; P1=~P1; P2=~P2; P3=~P3;
  582.   delay(1000);  
  583. }
  584. }
  585. void disp26()   //状态26 2个LED开始上下移动半圈(LED不亮流水)
  586. {
  587. P0=0x00;P1=0x00;P2=0x00;P3=0x00;
  588. for(i=0;i<8;i++)
  589. {
  590.   P0=~table1[i];
  591.   P2=~table1[i];
  592.   delay(200);
  593. }
  594. P0=0x00; P2=0x00;
  595. for(i=0;i<8;i++)
  596. {
  597.   P1=~table0[i];
  598.   P3=~table1[i];
  599.   delay(200);
  600. }

  601. for(i=0;i<8;i++)
  602. {
  603.   P1=~table1[i];
  604.   P3=~table0[i];
  605.   delay(200);
  606. }
  607. P1=0x00; P3=0x00;
  608. for(i=0;i<8;i++)
  609. {
  610.   P0=~table0[i];
  611.   P2=~table0[i];
  612.   delay(200);
  613. }
  614. }
  615. void disp27()   //状态27 逐步顺时针点亮P2、P1的LED,熄灭后,再顺时针点亮P0、P3的LED
  616. {
  617. P0=0xff; P1=0xff; P2=0xff; P3=0xff;
  618. for(j=0;j<2;j++)
  619. {
  620.   for(i=0;i<8;i++)
  621.   {
  622.    P2=table3[i];
  623.    P1=table3[i];
  624.    delay(100);
  625.   }
  626.   P2=0xff; P1=0xff;
  627.   for(i=0;i<8;i++)
  628.   {
  629.    P0=table2[i];
  630.    P3=table3[i];
  631.    delay(100);
  632.   }
  633.   P0=0xff; P3=0xff;
  634. }
  635. }
  636.    
  637. void disp28()   //状态28 P1、P2和P0、P3交替闪烁
  638. {
  639. for(i=0;i<2;i++)
  640. {
  641.   P1=0x00; P2=0x00; P0=0xff; P3=0xff;
  642.   delay(1000);
  643.   P1=0xff; P2=0xff; P0=0x00; P3=0x00;
  644.   delay(1000);
  645. }
  646. P1=0xff; P2=0xff; P0=0xff; P3=0xff;
  647. }
  648. void disp29()   //状态29 逐步顺时针点亮P2、P1的LED,再顺时熄灭后,再顺时针点亮P0、P3的LED,再顺时熄灭
  649. {
  650. P0=0xff; P1=0xff; P2=0xff; P3=0xff;
  651. for(j=0;j<2;j++)
  652. {
  653.   for(i=0;i<8;i++)
  654.   {
  655.    P2=table3[i];
  656.    P1=table3[i];
  657.    delay(100);
  658.   }
  659.   for(i=0;i<9;i++)
  660.   {
  661.    P2=table5[i];
  662.    P1=table5[i];
  663.    delay(100);
  664.   }
  665.   for(i=0;i<8;i++)
  666.   {
  667.    P0=table2[i];
  668.    P3=table3[i];
  669.    delay(100);
  670.   }
  671.   for(i=0;i<9;i++)
  672.   {
  673.    P0=table4[i];
  674.    P3=table5[i];
  675.    delay(100);
  676.   }
  677. }
  678. delay(200);
  679. }
  680. void disp30()   //状态30 逐步逆时针点亮P2、P1的LED,熄灭后,再逆时针点亮P0、P3的LED
  681. {
  682. P0=0xff; P1=0xff; P2=0xff; P3=0xff;
  683. for(j=0;j<2;j++)
  684. {
  685.   for(i=0;i<8;i++)
  686.   {
  687.    P2=table2[i];
  688.    P1=table2[i];
  689.    delay(100);
  690.   }
  691.   P2=0xff; P1=0xff;
  692.   for(i=0;i<8;i++)
  693.   {
  694.    P0=table3[i];
  695.    P3=table2[i];
  696.    delay(100);
  697.   }
  698.   P0=0xff; P3=0xff;
  699. }
  700. }
  701. void disp31()   //状态31 逐步逆时针点亮P2、P1的LED,再逆时熄灭后,再逆时针点亮P0、P3的LED,再逆时熄灭
  702. {
  703. P0=0xff; P1=0xff; P2=0xff; P3=0xff;
  704. for(j=0;j<2;j++)
  705. {
  706.   for(i=0;i<8;i++)
  707.   {
  708.    P2=table2[i];
  709.    P1=table2[i];
  710.    delay(100);
  711.   }
  712.   for(i=0;i<9;i++)
  713.   {
  714.    P2=table4[i];
  715.    P1=table4[i];
  716.    delay(100);
  717.   }
  718.   for(i=0;i<8;i++)
  719.   {
  720.    P0=table3[i];
  721.    P3=table2[i];
  722.    delay(100);
  723.   }
  724.   for(i=0;i<9;i++)
  725.   {
  726.    P0=table5[i];
  727.    P3=table4[i];
  728.    delay(100);
  729.   }
  730. }
  731. delay(200);
  732. }
  733. void disp32()   //状态32 LED自上而下逐步点亮,然后从下往上逐步熄灭
  734. {
  735. for(i=0;i<8;i++)
  736. {
  737.   P0=table3[i];
  738.   P2=table3[i];
  739.   delay(100);
  740. }
  741. for(i=0;i<8;i++)
  742. {
  743.   P1=table2[i];
  744.   P3=table3[i];
  745.   delay(100);
  746. }
  747. for(i=0;i<9;i++)
  748. {
  749.   P1=table5[i];
  750.   P3=table4[i];
  751.   delay(100);
  752. }
  753. for(i=0;i<9;i++)
  754. {
  755.   P0=table4[i];
  756.   P2=table4[i];
  757.   delay(100);
  758. }
  759. }
  760. void disp33()   //状态33 LED从左往右开始点亮(直到全亮),然后从左右两边开始熄灭(直到全部熄灭)
  761. {
  762. for(i=0;i<8;i++)
  763. {
  764.   P0=table2[i];
  765.   P1=table2[i];
  766.   delay(100);
  767. }
  768. for(i=0;i<8;i++)
  769. {
  770.   P2=table3[i];
  771.   P3=table2[i];
  772.   delay(100);
  773. }
  774. delay(500);
  775. for(i=0;i<9;i++)
  776. {
  777.   P2=table4[i];
  778.   P3=table5[i];
  779.   P1=table4[i];
  780.   P0=table4[i];
  781.   delay(100);
  782. }
  783. delay(300);
  784. }
  785. void disp34()   //状态34 LED从左往右开始点亮(直到全亮),然后从中间往左右边熄灭
  786. {
  787. for(i=0;i<8;i++)
  788. {
  789.   P2=table2[i];
  790.   P3=table3[i];
  791.   delay(100);
  792. }
  793. for(i=0;i<8;i++)
  794. {
  795.   P0=table3[i];
  796.   P1=table3[i];
  797.   delay(100);
  798. }
  799. delay(500);
  800. for(i=0;i<9;i++)
  801. {
  802.   P2=table5[i];
  803.   P3=table4[i];
  804.   P1=table5[i];
  805.   P0=table5[i];
  806.   delay(100);
  807. }
  808. delay(300);
  809. }
  810. void disp35()   //状态35  从P2.7、P1.7开始同时顺时针旋转,直到LED全亮
  811. {
  812. for(i=0;i<8;i++)
  813. {
  814.   P2=table3[i];
  815.   P1=table3[i];
  816.   delay(100);
  817. }
  818. for(i=0;i<8;i++)
  819. {
  820.   P3=table3[i];
  821.   P0=table2[i];
  822.   delay(100);
  823. }
  824. }
  825. void disp36()   //状态36  从P0.7、P3.1开始同时逆时针旋转,直到LED全亮
  826. {
  827. for(i=0;i<8;i++)
  828. {
  829.   P0=table3[i];
  830.   P3=table2[i];
  831.   delay(100);
  832. }
  833. for(i=0;i<8;i++)
  834. {
  835.   P1=table2[i];
  836.   P2=table2[i];
  837.   delay(100);
  838. }
  839. }
  840. void disp37()   //状态37 2个LED自上而下移动,并点亮最下2个LED,然后2个LED再自下而上回去,同时4个LED(上下各2个LED)再来回移动一次
  841. {
  842. for(i=0;i<8;i++)
  843. {
  844.   P0=table1[i];
  845.   P2=table1[i];
  846.   delay(100);
  847. }
  848. P0=0xff; P2=0xff;
  849. for(i=0;i<8;i++)
  850. {
  851.   P1=table0[i];
  852.   P3=table1[i];
  853.   delay(100);
  854. }

  855. for(i=0;i<8;i++)
  856. {
  857.   P1=table7[i];
  858.   P3=table6[i];
  859.   delay(100);
  860. }
  861. P1=0x7f; P3=0xfe;
  862. for(i=0;i<8;i++)
  863. {
  864.   P0=table0[i];
  865.   P2=table0[i];
  866.   delay(100);
  867. }

  868. for(i=0;i<8;i++)
  869. {
  870.   P0=table1[i];
  871.   P2=table1[i];
  872.   P1=table1[i];
  873.   P3=table0[i];
  874.   delay(200);
  875. }

  876. for(i=0;i<8;i++)
  877. {
  878.   P0=table0[i];
  879.   P1=table0[i];
  880.   P2=table0[i];
  881.   P3=table1[i];
  882.   delay(200);
  883. }
  884. P0=0xff;P1=0xff; P2=0xff;P3=0xff;
  885. }
  886. void disp38()   //状态38 逐步顺时针点亮P2、P1的LED,熄灭后,再顺时针点亮P0、P3的LED
  887. {
  888. P0=0xff; P1=0xff; P2=0xff; P3=0xff;
  889. for(j=0;j<2;j++)
  890. {
  891.   for(i=0;i<8;i++)
  892.   {
  893.    P2=table3[i];
  894.    P1=table3[i];
  895.    delay(100);
  896.   }
  897.   P2=0xff; P1=0xff;
  898.   for(i=0;i<8;i++)
  899.   {
  900.    P0=table2[i];
  901.    P3=table3[i];
  902.    delay(100);
  903.   }
  904.   P0=0xff; P3=0xff;
  905. }
  906. }
  907. void disp39()   //状态39 P1、P3LED(下半部分)一直亮,上半部分LED向外扩张亮,然后闪烁3次
  908. {
  909. P1=0x00; P3=0x00;
  910. for(i=0;i<8;i++)
  911. {
  912.   P0=table3[i];
  913.   P2=table3[i];
  914.   delay(150);
  915. }
  916. for(i=0;i<8;i++)
  917. {
  918.   P0=table3[i];
  919.   P2=table3[i];
  920.   delay(300);
  921. }
  922. for(i=0;i<4;i++)
  923. {
  924.   P0=~P0; P2=~P2;
  925.   delay(300);
  926. }
  927. delay(1000);
  928. }
  929. void disp40()   //状态40 LED从P3.0、P0.7开始逆时针同时熄灭,直到LED全部熄灭
  930. {
  931. for(i=0;i<9;i++)
  932. {
  933.   P3=table4[i];
  934.   P0=table5[i];
  935.   delay(100);
  936. }
  937. for(i=1;i<9;i++)
  938. {
  939.   P2=table4[i];
  940.   P1=table4[i];
  941.   delay(100);
  942. }
  943. delay(300);
  944. }
  945. void disp41()   //状态41 LED从P2.7、P1.7开始顺时针同时熄灭,直到全部熄灭
  946. {
  947. for(i=0;i<9;i++)
  948. {
  949.   P2=table5[i];
  950.   P1=table5[i];
  951.   delay(100);
  952. }
  953. for(i=1;i<9;i++)
  954. {
  955.   P0=table4[i];
  956.   P3=table5[i];
  957.   delay(100);
  958. }
  959. delay(300);  
  960. }
  961. void main()
  962. {
  963. while(1)
  964. {  
  965.   disp22();  //装态22 2个LED自上而下移动(循环5次,且频率渐快,到最快时持续循环16次,然后循环5次频率再逐渐降低)
  966.   disp0();  //状态0 所有LED闪烁3次
  967.   disp1();  //状态1 LED顺时针转一圈
  968.   disp2();  //状态2 LED逆时针转一圈
  969.   disp3();  //状态3 4个LED同时顺时、逆时针移动1/4圈
  970.   disp4();  //状态4  2个LED同时顺时针移动半圈
  971.   disp5();  //状态5  2个LED同时逆时针移动半圈
  972.   disp6();  //状态6 LED自上而下逐渐点亮(一半点亮一半不亮)
  973.   disp7();  //状态7 LED自下而上逐渐点亮(直到全部点亮)
  974.   disp0();  //状态0 所有LED闪烁3次
  975.   disp8();  //状态8 间断8格的4个LED亮并逆时针旋转
  976.   disp9();  //状态9 间断8格的4个LED亮,然后逆时针逐渐点亮(直到全部点亮)
  977.   disp10();  //状态10 从LED全部亮到全不亮(间断8格的4个LED开始逆时针熄灭)
  978.   disp11();  //状态11 间断8格的4个LED亮并顺时针旋转
  979.   disp12();  //间断8格的4个LED亮,然后顺时针逐渐点亮(直到全部点亮)
  980.   disp13();  //状态13 从LED全部亮到全不亮(间断8格的4个LED开始顺时针熄灭)
  981.   disp14();  //状态14 从LED不亮到全亮(从P0.0、P1.0、P2.0、P3.7开始逐布点亮)  
  982.   disp15();  //状态15 从LED全亮到全不亮(从P0.7、P1.7、P2.7、P3.0开始逐步熄灭)
  983.   disp16();  //状态16 LED灯交替闪烁(频率有慢变快)
  984.   disp17();  //状态17 LED从P0.7开始逆时针逐步点亮,并且速度会逐步提高
  985.   disp18();  //状态18 LED从P0.7开始逆时针逐步点亮(每亮8位后就熄灭)
  986.   disp19();  //状态19 LED从P2.7开始顺时针逐步点亮,(循环2次)并且速度会逐步提高
  987.   disp20();  //状态20 LED从P2.7开始顺时针逐步点亮(每亮8位后就熄灭)
  988.   disp21();  //状态21 2个LED开始上下移动半圈
  989.   disp22();  //装态22 2个LED自上而下移动(循环5次,且频率渐快,到最快时持续循环16次,然后循环5次频率再逐渐降低
  990.   disp23();  //状态23 LED上下交替闪烁
  991.   disp39();  //状态39 P1、P3LED(下半部分)一直亮,上半部分LED向外扩张亮,然后闪烁3次
  992.   disp24();  //状态24 LED左右交替闪烁
  993.   disp25();  //状态25 LED交替闪烁
  994.   disp8();  //状态8 间断8格的4个LED亮并逆时针旋转
  995.   disp9();  //状态9 间断8格的4个LED亮,然后逆时针逐渐点亮(直到全部点亮)
  996.   disp10();  //状态10 从LED全部亮到全不亮(间断8格的4个LED开始逆时针熄灭)
  997.   disp26();  //状态26 2个LED开始上下移动半圈(LED不亮流水)
  998.   disp27();  //状态27 逐步顺时针点亮P2、P1的LED,熄灭后,再顺时针点亮P0、P3的LED
  999.   disp28();  //状态28 P1、P2和P0、P3交替闪烁
  1000.   disp38();  //状态38 逐步顺时针点亮P2、P1的LED,熄灭后,再顺时针点亮P0、P3的LED
  1001.   disp29();  //状态29 逐步顺时针点亮P2、P1的LED,再顺时熄灭后,再顺时针点亮P0、P3的LED,再顺时熄灭
  1002.   disp30();  //状态30 逐步逆时针点亮P2、P1的LED,熄灭后,再逆时针点亮P0、P3的LED
  1003.   disp31();  //状态31 逐步逆时针点亮P2、P1的LED,再逆时熄灭后,再逆时针点亮P0、P3的LED,再逆时熄灭
  1004.   disp32();  //状态32 LED自上而下逐步点亮,然后从下往上逐步熄灭
  1005.   disp33();  //状态33 LED从左往右开始点亮(直到全亮),然后从左右两边开始熄灭(直到全部熄灭)
  1006.   disp37();  //状态37 2个LED自上而下移动,并点亮最下2个LED,然后2个LED再自下而上回去,同时4个LED(上下各2个LED)再来回移动一次
  1007.   disp36();  //状态36  从P0.7、P3.0开始同时逆时针旋转,直到LED全亮
  1008.   disp40();  //状态40 LED从P3.0、P0.7开始逆时针同时熄灭,直到LED全部熄灭
  1009.   disp35();  //状态35  从P2.7、P1.7开始同时顺时针旋转,直到LED全亮
  1010.   disp41();  //状态41 LED从P2.7、P1.7开始顺时针同时熄灭,直到全部熄灭
  1011.   disp34();  //状态34 LED从左往右开始点亮(直到全亮),然后从中间往左右边熄灭
  1012.   disp28();  //状态28 P1、P2和P0、P3交替闪烁
  1013. }
  1014. }
复制代码


回复

使用道具 举报

ID:72624 发表于 2015-6-23 09:18 | 显示全部楼层
支持一下,感觉有点乱,能精炼一下更好
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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