标题: 光立方程序源码下载(烟花+雨滴+旋转效果)带视频 [打印本页]
作者: my_way_old    时间: 2015-3-18 20:39
标题: 光立方程序源码下载(烟花+雨滴+旋转效果)带视频
本帖最后由 my_way_old 于 2015-5-2 21:36 编辑

http://player.youku.com/player.php/sid/XOTEyNzI0MDU2/v.swf
简单的显示功能，网上查资料，整理，编程，结合大家的智慧，可以说是站在巨人的肩膀在行动


可以说这次是个很好的学习过程

原理图+PCB ： guanglifa_PCB.rar (1.41 MB, 下载次数: 532)
有说要分享下的，不是很完整，因为我当时是部分用的小模块在外加的，还有64根短跳线和八根锁存器片选跳线等
大家有兴趣的将就参考下吧


其中on_off（）  是写了一个暂停函数，通过按键来触发，程序编写使其定住时显示的是定住那瞬间的画面，而不单单是一行LED，但只能是有调用zhen（）函数的那些图案

源码下载:http://www.51hei.com/bbs/dpj-31826-1.html


作者: my_way_old    时间: 2015-3-18 20:41
主程序：
  1. #include "STC.h"         //STC12C5A60S2头文件
  2. #include "MyType.h"      //常用数据类型定义
  3. #include "led_do.h"         //LED驱动头文件
  4. #include "intrins.h"
  5. #include "shuzu.h"     //字模数据
  6. int flag=0,flag1=0,a=0;
  7. void LED_Init();
  8. void ON_OFF();
  9. void Delayms(uint16 n);
  10. void Delay(uint16 z);
  11. bit kk1;



  15. //X 片选   Y 数据  Z 2803
  16. void main()
  17. {
  18.         uint8 i,j;       
  19.         Z=0;       
  20.    while(k2==1);
  21.    LED_Init();
  22.    for(i=0;i<2;i++)
  23.            DOT_PWM(0,0,0,120);
  24.         Delayms(800);
  25.         CUBE_LOG6(NUM2,3);         // 倒数321
  26.         CLEAR();
  27.         while(1)
  28.         {
  29.                 zimu(number,13,20,1);   //LED CUBE       
  30.                 CLEAR();
  31.                 denghuo(3);         //逐亮逐灭               
  32.                 CUBE_LOG5();   //一个府面的LED,从下向上
  33.                 Delayms(100);
  34.                 LOG18();                  //从顶层，向下一层层点亮，到全亮
  35.                 Delayms(100);
  36.                 LOG16();                //全亮
  37.                 donghua(bianxing_table,11,1,24);  //变形收缩，释放四个小正方形
  38.                 Delayms(100);
  39.                 FIRE(0,0);
  40.                 FIRE(0,7);
  41.                 FIRE(7,7);
  42.                 FIRE(7,0);       
  43.                                        
  44.                 CUBE_LOG5();  //逐面点亮一个府面的LED,从下向上流动
  45.                 shalou1();
  46.                 fn(4);          //Delayms(8000); //沙漏痕迹
  47.                 LOG12_1(); //落潮                  
  48.                 for(i=0;i<1;i++)
  49.                      for(j=0;j<3;j++)
  50.                               cube(1,j,6);          //空心立体放大缩小
  51.                 LOG5();          //正方体收缩
  52.                 LOG1(); //small cube    //小正方体扩大，左右小正方体，四角小正体
  53.                
  54.                 CUBE_LOG5();  //逐面点亮一个府面的LED,从下向上流动
  55.                 CLEAR();
  56.                 LOG13(); // 下雨
  57.                 rain(1,10,9);
  58.                 CLEAR();
  59.                 LOG22(); //雨滴
  60.                 donghua(sin_cube_table,14,8,7);//波面起伏          //////
  61.                 CUBE_LOG9();//雨帘
  62.                 CUBE_LOG10();//音乐律动
  63.                 LOG2(2,4);
  64.                 LOG2(4,2);
  65.                 CLEAR();               
  66.                 CUBE_LOG11();//水平表面顺时针环绕

  68.                 link00();  //四个角收缩，全亮

  70.                 LOG12(); //波浪
  71.                 for(i=0;i<2;i++)
  72.                 LOG17(); //从底层，一层层点亮，到全亮
  73.                 donghua(bianxing_table,11,1,24);  //变形收缩

  75.                 LOG23(); //音柱        ////
  76.                        
  77.                 FIRE(1,2);
  78.                 shalou1();
  79.                 LOG2(3,4);
  80.                
  81.                 FIRE(6,3);

  83.                 flash0(2); //条状升降
  84.                    
  85.            fn(4);          //Delayms(8000); //沙漏痕迹
  86.            flash0(5);  //底面到顶面，led上下移动
  87.                 xuanzhuantiao(0,8,3);//空心旋转
  88.            qumianxuanzhuan(1,10,3);
  89.             qumianxuanzhuan(0,10,3);
  90.            linkpc1(10);         //一个Z面从上到下

  92.             pc1(4,3);   //由下到上闪亮，再一个Z面从上到下
  93.                 Delayms(100);
  94.                 CLEAR();
  95.                  denghuo(3);         //逐亮逐灭
  96.                  leitu(yc_table,3,2);        //I LOVE U
  97.                  CLEAR();
  98.                  link_pingmian1(1);        //一行LED从左到右

  100.             pingmian1(8,3);           //水平面逆时针环绕

  102.                 for(i=0;i<8;i++)
  103.              print(tab_print+i*8,0);
  104.             jb0(10,3);         //竖直面环绕

  106.                 link(8); //旋转衔接
  107.                
  108.                 xuanzhuantiao(1,5,3);//平面旋转
  109.                 xuanzhuantiao2(2,3); //移动旋转
  110.                 qumianxuanzhuan(1,10,4);
  111.             qumianxuanzhuan(0,10,4);
  112.                 qumianxuanzhuan2(13,8);//曲面摆动
  113.                
  114.              xuanzhuantiao(1,3,7);
  115.       xuanzhuantiao(1,3,5);
  116.       xuanzhuantiao(1,5,3);         

  118.         donghua(bianxing_table,11,1,24);  //变形收缩，释放四个小正方形
  119.     xzcube();                   //三方向旋转，再全亮
  120.     donghua(y_table,6,5,5); //四角小正方形旋转
  121.     donghua(x_table,6,5,5);
  122.     donghua(z_table,6,5,5);
  123.             link00();                                                                                                                                                                    

  125.         shensuo(5);          
  126.         donghua(sin_cube_table,14,8,5);//波面起伏
  127.         for(i=0;i<1;i++)
  128.      for(j=0;j<3;j++)
  129.       cube(0,j,6);         //实心立体放大缩小
  130.          donghua(hart_table,2,10,32); //跳动的心   Delayms(8000);
  131.             rain(0,10,9);
  132.                 LOG2(3,4);
  133.                 CLEAR();
  134.         while(1);
  135.         }
  136. }


  139. void LED_Init()
  140. {
  141.         IT0=1;
  142.         EX0=1;
  143.         EA=1;
  144.         kk1=1;
  145. }
  146. void EX_INT0() interrupt  0
  147. {
  148.         Delayms(20);
  149.                 kk1=~kk1;                       
  150. }
  151. void Delayms(uint16 n)
  152. {
  153.   uint16 x,y;

  155.   for(x=n;x>0;x--)
  156.     for(y=0;y<600;y++);
  157. }  
  158. void Delay(uint16 z)
  159. {
  160.   uint8 i,t;
  161.   for(t=z;t>0;t--)
  162.     for(i=0;i<110;i++);
  163. }
复制代码
作者: my_way_old    时间: 2015-3-18 20:41
led_do.c文件：
  1. #include "led_do.h"         //LED驱动头文件
  2. #include "shuzu.h"
  3. #include "MyType.h"      //常用数据类型定义
  4. //#include "Delay.h"       //延时函数头文件
  5. #include "stdlib.h"
  6. #include "intrins.h"
  7. void Delayms(uint16 n);
  8. void Delay(uint16 z);
  9. //清零
  10. void CLEAR()
  11. {   
  12.         Y=0x00; //设置Y轴坐标
  13.         X=0xff;   
  14.         X=0x00; //锁存X轴坐标
  15.         Z=0x00; //熄灭所有LED  
  16. }

  18. /*********************************************************************************************
  19. 函数名：点亮某一坐标点上的LED,坐标是:(x,y,z)
  20. 调  用：LED_DOT_ON (?);
  21. 参  数：x:x轴, y:y轴, z:z轴
  22. 结  果：点亮相对应坐标点上的一个LED,其他坐标点上的LED熄灭
  23. /*********************************************************************************************/
  24. void LED_DOT_ON(uint8 x1, uint8 y1, uint8 z1)
  25. {   uint8 MOVE[]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};
  26.         X=MOVE[x1];
  27.         Y=MOVE[y1];
  28.         Z=MOVE[z1];
  29.         X=0x00;
  30.        
  31. }

  33. /*******************************************************************
  34. 某坐标灯，作呼吸灯闪烁
  35. ********************************************************************/
  36. void DOT_PWM(uchar x1,uchar y1,uchar z1,int T)
  37. {
  38.         uint16 LOW=0;
  39.         if(T<0) T=100;
  40.         if((x1>=0||x1<8)&&(y1>=0||y1<8)&&(z1>=0||z1<8))
  41.         {
  42.                 CLEAR();
  43.                 Z1 = 0xff;
  44.                 Delay(100);
  45.                
  46.                 for(LOW=1;LOW<T;LOW++)
  47.                 {
  48.                         LED_DOT_ON(x1,y1,z1);
  49.                         Delay(LOW);
  50.                         CLEAR();
  51.                         Delay(T-LOW);
  52.                 }
  53.                
  54.                 LED_DOT_ON(x1,y1,z1);
  55.                 Delay(200);
  56.        
  57.                 for(LOW=T-1;LOW>0;LOW--)
  58.                 {
  59.                         LED_DOT_ON(x1,y1,z1);
  60.                         Delay(LOW);
  61.                         CLEAR();
  62.                         Delay(T-LOW);  
  63.                 }
  64.         }         
  65. }

  67. /*********************************************************************************************
  68. 函数名：图形1
  69. 调  用：CUBE_LOG1 ();
  70. 结  果：逐一叠加点亮坐标为(0,y,0)点上的一轴LED,其他坐标点上的LED熄灭
  71.         自下向上，一列
  72. /*********************************************************************************************/
  73. void CUBE_LOG1()
  74. {
  75.         uint8 i;
  76.        
  77.         CLEAR();   
  78.        
  79.         Z = 0x01; //设置Y轴坐标
  80.         X = 0x01; //设置X轴坐标  
  81.        
  82.         for(i=0;i<8;i++)
  83.         {
  84.                 Y = ADD_Y[i]; //锁存X轴坐标
  85.                 Delayms(300);
  86.         }
  87.         X = 0x00;
  88. }  

  90. /*********************************************************************************************
  91. 函数名：图形2
  92. 调  用：CUBE_LOG2 ();
  93. 结  果：逐一轴叠加点亮坐标为(0,y,0~7)点上的一轴LED,其他坐标点上的LED熄灭(左侧面)
  94. /*********************************************************************************************/
  95. void CUBE_LOG2()
  96. {
  97.         uint8 y;
  98.        
  99.         Z = 0x00; //熄灭所有LED  
  100.         Y = 0x80; //设置Y轴坐标
  101.         X = 0x01; //设置X轴坐标   
  102.         X = 0x00; //锁存X轴坐标
  103.         Z = 0xff; //(0,7,z)轴上的LED
  104.        
  105.         for(y=0;y<8;y++)
  106.         {
  107.                 Y |= 0x80>>y;
  108.                 X = 0x01; //设置X轴坐标   
  109.                 X = 0x00; //锁存X轴坐标
  110.                 Delayms(200);
  111.         }
  112. }  
  113. /*********************************************************************************************
  114. 函数名：图形3
  115. 调  用：CUBE_LOG3 ();
  116. 结  果：逐面点亮一个侧面的LED,从左向右流动,其他坐标点上的LED熄灭
  117. /*********************************************************************************************/
  118. void CUBE_LOG3()
  119. {
  120.         uint8 x;
  121.        
  122.         Z = 0x00; //熄灭所有LED   
  123.         Y = 0xff; //设置Y轴坐标
  124.         X = 0x01; //设置X轴坐标   
  125.         X = 0x00; //锁存X轴坐标
  126.         Z = 0xff; //(0,7,z)轴上的LED
  127.        
  128.         for(x=0;x<8;x++)
  129.         {
  130.                 Y = 0x00; //设置Y轴坐标
  131.                 X = 0xff; //设置X轴坐标   
  132.                 X = 0x00; //锁存X轴坐标
  133.                
  134.                 Y = 0xff; //设置Y轴坐标
  135.                 X = 0x01<<x; //设置X轴坐标           
  136.                 X = 0x00; //锁存X轴坐标
  137.                 Delayms(400);
  138.         }
  139. }
  140. /*********************************************************************************************
  141. 函数名：图形4
  142. 调  用：CUBE_LOG4 ();
  143. 结  果：逐面点亮一个正面的LED,从前向后流动,其他坐标点上的LED熄灭
  144. /*********************************************************************************************/
  145. void CUBE_LOG4()
  146. {
  147.         uint8 y;
  148.        
  149.         Z = 0x00; //熄灭所有LED   
  150.         Y = 0x80; //设置Y轴坐标
  151.         X = 0xff; //设置X轴坐标   
  152.         X = 0x00; //锁存X轴坐标
  153.         Z = 0xff; //(0,7,z)轴上的LED
  154.        
  155.         for(y=0;y<8;y++)
  156.         {
  157.                 Y = 0x80>>y; //设置Y轴坐标
  158.                 X = 0xff; //设置X轴坐标   
  159.                 X = 0x00; //锁存X轴坐标
  160.                 Delayms(400);
  161.         }
  162. }         
  163. /*********************************************************************************************/

  165. /*********************************************************************************************
  166. 函数名：图形5
  167. 调  用：CUBE_LOG5 ();
  168. 结  果：逐面点亮一个府面的LED,从下向上流动,其他坐标点上的LED熄灭
  169. /*********************************************************************************************/
  170. void CUBE_LOG5()
  171. {
  172.         uint8 i;

  174.         Z = 0x00; //熄灭所有LED  
  175.         Y = 0xff; //设置Y轴坐标
  176.         X = 0xff; //设置X轴坐标   
  177.         X = 0x00; //锁存X轴坐标
  178.         Z = 0x01; //(0,7,z)轴上的LED
  179.        
  180.         for(i=0;i<8;i++)
  181.         {
  182.                 Z = 0x01<<i; //(0,7,z)轴上的LED
  183.                 Delayms(400);
  184.         }
  185. /*        for(i=0;i<4;i++)
  186.         {
  187.                 CLEAR();
  188.                 Z = 0x80>>i;
  189.                 Y = SHALOU[i]; //设置Y轴坐标
  190.                 X = SHALOU[i]; //设置X轴坐标   
  191.                 X = 0x00; //锁存X轴坐标
  192.                 Delayms(500);
  193.         }*/                  
  194. }
  195. /*********************************************************************************************
  196. 函数名：图形6
  197. 调  用：CUBE_LOG6 ();
  198. CUBD_LOG6(NUM2,3);
  199. 结  果：开机倒数(3,2,1)：
  200. *********************************************************************************************/                
  201. void CUBE_LOG6(uint8 *NUM,uint8 n)
  202. {
  203.         int8 i,x,y,f,num;                          
  204.         Z = 0x00; //熄灭所有LED
  205.         Y = 0x00; //设置Y轴坐标
  206.         X = 0xff; //设置X轴坐标   
  207.         X = 0x00; //锁存X轴坐标     
  208.        
  209.         for(num=0;num<n;num++)
  210.         {
  211.                 for(f=0;f<2;f++)
  212.                 {
  213.                         for(x=0;x<8;x++)
  214.                         {
  215.                                 for(i=0;i<6;i++)
  216.                                 {
  217.                                         for(y=0;y<8;y++)
  218.                                         {
  219.                                                 Y = 0x00;
  220.                                                 X = 0xff;     
  221.                                                 X = 0x00;   
  222.                                                 Y = 0x80>>y;    //设置Y轴坐标
  223.                                                
  224.                                                 if(f == 0)
  225.                                                 {
  226.                                                         X = ADD_X[x]; //设置X轴坐标
  227.                                                         X = 0x00;       //锁存X轴坐标
  228.                                                 }
  229.                                                
  230.                                                 if(f == 1)
  231.                                                 {
  232.                                                         X = ~ADD_X[x]; //设置X轴坐标
  233.                                                         X = 0x00;      //锁存X轴坐标
  234.                                                 }   
  235.                                                 Z = NUM[num*8+y];
  236.                                                 Delayms(2+2*f);
  237.                                         }
  238.                                 }
  239.                         }       
  240.                 }
  241.                

  243.                 for(f=0;f<2;f++)
  244.                 {
  245.                         for(i=0;i<50;i++)
  246.                         {
  247.                                 for(y=0;y<8;y++)
  248.                                 {
  249.                                         Y = 0x00;
  250.                                         X = 0xff;     
  251.                                         X = 0x00;
  252.                                        
  253.                                         Y = 0x80>>y; //设置X轴坐标   
  254.                                         X = 0x01; //设置Y轴坐标
  255.                                         X = 0x00; //锁存X轴坐标
  256.                                         Z = NUM[num*8+y];
  257.                                         Delayms(2);
  258.                                 }
  259.                         }
  260.                 }
  261.         }       
  262. }
  263. /*********************************************************************************************
  264. 函数名：LOG3()
  265. 结  果：前后面
  266. *********************************************************************************************/
  267. void LOG3()
  268. {
  269.         uint8 z;
  270.        
  271.         CLEAR();   
  272.        
  273.         X = 0x01; //设置X轴坐标   
  274.         X = 0x00; //锁存X轴坐标

  276.         for(z=0;z<8;z++)
  277.         {       
  278.                 Y |= 0x01<<z;
  279.                 X = 0x01; //设置X轴坐标   
  280.                 X = 0x00; //锁存X轴坐标
  281.                 Z |= 0x80 >>z; //锁存X轴坐标
  282.                 Delayms(200);
  283.         }
  284. }
  285. void LOG4()
  286. {
  287.         uint8 i;
  288.        
  289.         CLEAR();  

  291.         for(i=0;i<8;i++)
  292.         {       
  293.                 Y = 0xff>>i;
  294.                 X = 0x01; //设置X轴坐标   
  295.                 X = 0x00; //锁存X轴坐标
  296.                 Z = 0xff <<i; //锁存X轴坐标
  297.                 Delayms(200);
  298.         }
  299. }
  300. void LOG5()
  301. {
  302.         uint16 CYCLE=80,PWM_LOW=0;
  303.         uint8 BOOT[] = {0xff,0x7e,0x3c,0x18};
  304.         uint8 i;         

  306.         for(i=0;i<4;i++)
  307.         {          
  308.                 for(PWM_LOW=1;PWM_LOW<CYCLE;PWM_LOW++)
  309.                 {
  310.                 Y = BOOT[i];
  311.                 X = BOOT[i];   
  312.                 X = 0x00;
  313.                 Z = BOOT[i];
  314.                 Delay(PWM_LOW);
  315.                 Y = 0x00;
  316.                 X = 0xff;   
  317.                 X = 0x00;
  318.                 Z = 0x00;
  319.                 Delay(CYCLE-PWM_LOW);
  320.                 }

  322.                 Y = BOOT[i];
  323.                 X = BOOT[i];   
  324.                 X = 0x00;
  325.                 Delay(50);

  327.                 for(PWM_LOW=CYCLE-1;PWM_LOW>0;PWM_LOW--)
  328.                 {
  329.                 Y = BOOT[i];
  330.                 X = BOOT[i];   
  331.                 X = 0x00;
  332.                 Z = BOOT[i];
  333.                 Delay(PWM_LOW);
  334.                 Y = 0x00;
  335.                 X = 0xff;   
  336.                 X = 0x00;
  337.                 Z = 0x00;
  338.                 Delay(CYCLE-PWM_LOW);  
  339.                 }
  340.         }
  341. }
  342. void LOG6()        //全亮，X面逐层收回
  343. {
  344.         uint8 i,y;
  345.         X=0xff;
  346.         Y=0xff;
  347.         X=0x00;
  348.         Delayms(500);
  349.         Z=0xff;
  350.         Z = 0xff; //(0,7,z)轴上的LED
  351.         for(i=0;i<8;i++)          
  352.         for(y=0;y<9;y++)
  353.         {
  354.                 Y = 0xff<<y;
  355.                 X = MOVE[i]; //设置X轴坐标   
  356.                 X = 0x00; //锁存X轴坐标
  357.                 Delayms(100);
  358.         }

  360. }


  363. void LOG7()
  364. {
  365.         uint8 x;
  366.          //(0,7,z)轴上的LED
  367.        
  368.         for(x=0;x<8;x++)
  369.         {
  370.                 Y = 0xff;
  371.                 X = ADD_X[x]; //设置X轴坐标   
  372.                 X = 0x00; //锁存X轴坐标
  373.                 Z = 0xff;
  374.                 Delayms(200);
  375.         }
  376. }


  379. void LOG8()
  380. {
  381.         uint8 z;
  382.        
  383.         Y = 0x01;
  384.         X = 0xFF; //设置X轴坐标   
  385.         X = 0x00; //锁存X轴坐标
  386.   
  387.         for(z=0;z<8;z++)
  388.         {
  389.                 Z = 0xff>>z;
  390.                 Delayms(200);
  391.         }
  392. }
  393. void LOG9()
  394. {
  395.         uint8 y;
  396.        
  397.         Z = 0x01;
  398.        
  399.         for(y=0;y<8;y++)
  400.         {
  401.                 Y |= 0x01<<y;
  402.                 X = 0xFF; //设置X轴坐标   
  403.                 X = 0x00; //锁存X轴坐标
  404.                 Delayms(200);
  405.         }
  406. }
  407. void LOG10()
  408. {
  409.         uint8 i;
  410.         uint8 SO[]={0XFF,0X7F,0X3F,0X1F,0X0F,0X7,0X03,0X01};
  411.         for(i=1;i<8;i++)
  412.         {
  413.                 CLEAR();
  414.                 Y=SO[i];
  415.                 X=SO[i];
  416.                 Z=0X01;
  417.                 Delayms(800);       
  418.         }
  419. }

  421. void LOG11()
  422. {
  423.         uint8 x;
  424.         CLEAR();
  425.         Y=0XFF;
  426.         Z = 0xff; //(0,7,z)轴上的LED
  427.   
  428.         for(x=0;x<8;x++)
  429.         {
  430.         X |= 0x80>>x; //设置X轴坐标   
  431.         X = 0x00; //锁存X轴坐标
  432.         Delayms(200);
  433.         }
  434. }

  436. void shalou1()//正向
  437. {
  438.         int8 i,j,d;
  439.         for(j=0;j<8;j++)
  440.         {       
  441.                 for(d=0;d<10*(8-j);d++)
  442.                 {
  443.                         if(j<3)
  444.                                 for(i=0;i<=j;i++)
  445.                                 {       
  446.                                         CLEAR();
  447.                                         Y=SHALOU[i];
  448.                                         X=SHALOU[i];
  449.                                         X=0x00;
  450.                                         Z=0x80>>i;
  451.                                         Delayms(3);
  452.                                 }
  453.                         if(j>3)
  454.                                 for(i=j-4;i<=j;i++)
  455.                                 {       
  456.                                         CLEAR();
  457.                                         Y=SHALOU[i];
  458.                                         X=SHALOU[i];
  459.                                         X=0x00;
  460.                                         Z=0x80>>i;
  461.                                         Delayms(5);
  462.                                 }
  463.                 }
  464.         }
  465.         for(j=3;j>=0;j--)
  466.                 {       
  467.                         for(d=0;d<5*(8-j);d++)
  468.                         {       
  469.                                 for(i=j;i>=0;i--)
  470.                                 {       
  471.                                         CLEAR();
  472.                                         Y=SHALOU[i];
  473.                                         X=SHALOU[i];
  474.                                         X=0x00;
  475.                                         Z=0x01<<i;
  476.                                         Delayms(5);                       
  477.                                 }
  478.                         }
  479.                 }
  480.                 Z=0X00;
  481. }

  483. void shalou()  //反向
  484. {
  485.         int8 i,j,d;
  486.         for(j=0;j<8;j++)
  487.         {       
  488.                 for(d=0;d<5*(8-j);d++)
  489.                 {
  490.                         for(i=0;i<=j;i++)
  491.                         {       
  492.                                 CLEAR();
  493.                                 Y=SHALOU[i];
  494.                                 X=SHALOU[i];
  495.                                 X=0x00;
  496.                                 Z=0x01<<i;
  497.                                 Delayms(3);
  498.                         }
  499.                 }
  500.         }
  501.         for(j=7;j>=0;j--)
  502.         {       
  503.                 for(d=0;d<5*(8-j);d++)
  504.                 {       
  505.                         for(i=j;i>=0;i--)
  506.                         {       
  507.                                 CLEAR();
  508.                                 Y=SHALOU[i];
  509.                                 X=SHALOU[i];
  510.                                 X=0x00;
  511.                                 Z=0x80>>i;
  512.                                 Delayms(3);                       
  513.                         }
  514.                 }
  515.         }
  516. }
  517. void LOG12()                //波浪
  518. {
  519.         uint8 y,i,d;
  520.         uint8 WAVE[]={0X01,0X01,0X01,0X01,0X01,0X01,0X01,0X01,
  521.                                   0X01,0X01,0X01,0X03,0X03,0X01,0X01,0X01,
  522.                                   0X01,0X01,0X03,0X07,0X07,0X03,0X01,0X01,
  523.                                   0X01,0X03,0X07,0X0f,0X0f,0X07,0X03,0X01,
  524.                                   0X03,0X07,0X0f,0X1f,0X1f,0X0f,0X07,0X03,
  525.                                   0X07,0X0f,0X1f,0X3f,0X3f,0X1f,0X0f,0X07,
  526.                                   0X0f,0X1f,0X3f,0X7f,0X7f,0X3f,0X1f,0X0f,
  527.                                   0X1f,0X3f,0X7f,0Xff,0Xff,0X7f,0X3f,0X1f,};
  528.         CLEAR();
  529.         for(i=0;i<120;i++)
  530.                 for(d=0;d<8;d++)
  531.                         {
  532.                                 if(i<8)
  533.                                         for(y=0;y<i+1;y++)
  534.                                         {
  535.                                                 Y=MOVE[y];
  536.                                                 X=0XFF;
  537.                                                 Z=WAVE[i-y];
  538.                                         }
  539.                                 else  
  540.                                         for(y=0;y<8;y++)
  541.                                         {
  542.                                                 Y=MOVE[y];
  543.                                                 X=0XFF;
  544.                                                 if(i<64)
  545.                                                 Z=WAVE[i-y];
  546.                                                 if(i>63)
  547.                                                 Z=WAVE[119-(i-y)];
  548.                                                 Delayms(5);
  549.                                         }
  550.                         }
  551. }

  553. void LOG12_1()           //涨潮
  554. {
  555.         uint8 y,i,d;
  556.         uint8 WAVE[]={0X01,0X01,0X01,0X01,0X01,0X01,0X01,0X01,
  557.                                   0X01,0X01,0X01,0X03,0X03,0X01,0X01,0X01,
  558.                                   0X01,0X01,0X03,0X07,0X07,0X03,0X01,0X01,
  559.                                   0X01,0X03,0X07,0X0f,0X0f,0X07,0X03,0X01,
  560.                                   0X03,0X07,0X0f,0X1f,0X1f,0X0f,0X07,0X03,
  561.                                   0X07,0X0f,0X1f,0X3f,0X3f,0X1f,0X0f,0X07,
  562.                                   0X0f,0X1f,0X3f,0X7f,0X7f,0X3f,0X1f,0X0f,
  563.                                   0X1f,0X3f,0X7f,0Xff,0Xff,0X7f,0X3f,0X1f,};
  564.         CLEAR();
  565.         for(i=0;i<120;i++)
  566.                 for(d=0;d<8;d++)
  567.                         {
  568.                                 if(i<8)
  569.                                         for(y=0;y<i+1;y++)
  570.                                         {
  571.                                                 Y=MOVE[y];
  572.                                                 X=0XFF;
  573.                                                 Z=WAVE[i-y];
  574.                                         }
  575.                                 else  
  576.                                         for(y=0;y<8;y++)
  577.                                         {
  578.                                                 Y=MOVE[y];
  579.                                                 X=0XFF;
  580.                                                 if(i<64)
  581.                                         {        Z=WAVE[i-y];
  582.                                                 Delayms(5);           }
  583.                                         }
  584.                         }
  585. }

  587. void LOG12_2()           //落潮
  588. {
  589. uint8 y,i,d;
  590.         uint8 WAVE[]={0X01,0X01,0X01,0X01,0X01,0X01,0X01,0X01,
  591.                                   0X01,0X01,0X01,0X03,0X03,0X01,0X01,0X01,
  592.                                   0X01,0X01,0X03,0X07,0X07,0X03,0X01,0X01,
  593.                                   0X01,0X03,0X07,0X0f,0X0f,0X07,0X03,0X01,
  594.                                   0X03,0X07,0X0f,0X1f,0X1f,0X0f,0X07,0X03,
  595.                                   0X07,0X0f,0X1f,0X3f,0X3f,0X1f,0X0f,0X07,
  596.                                   0X0f,0X1f,0X3f,0X7f,0X7f,0X3f,0X1f,0X0f,
  597.                                   0X1f,0X3f,0X7f,0Xff,0Xff,0X7f,0X3f,0X1f,};
  598.         CLEAR();
  599.         for(i=0;i<120;i++)
  600.                 for(d=0;d<8;d++)
  601.                         {
  602.                                 if(i<8)
  603.                                         for(y=0;y<i+1;y++)
  604.                                         {
  605.                                                 Y=MOVE[y];
  606.                                                 X=0XFF;
  607.                                                 Z=WAVE[i-y];
  608.                                         }
  609.                                 else  
  610.                                         for(y=0;y<8;y++)
  611.                                         {
  612.                                                 Y=MOVE[y];
  613.                                                 X=0XFF;
  614.                                                 if(i>63)
  615.                                         {        Z=WAVE[119-(i-y)];
  616.                                                 Delayms(5);         }
  617.                                         }
  618.                         }

  620. }

  622. void LOG13()
  623. {
  624.         uint16 LOW=0;
  625.         uint8 d,x,y,z,t,i,T=1500;
  626.         CLEAR();
  627.         for(d=0;d<25;d++)
  628.         {
  629.                 x=rand()%8;
  630.                 y=rand()%8;
  631.                 z=(rand()%4)+4;
  632.                 t=(rand()%40)+30;       
  633.                 for(LOW=1;LOW<T;LOW+=10)
  634.                 {
  635.                         Y=MOVE[y];
  636.                         X=MOVE[x];
  637.                         X=0X00;
  638.                         Z=MOVE[z];
  639.                         Delay(LOW);
  640.                         CLEAR();
  641.                         Delay(T-LOW);
  642.                 }
  643.                 Y=MOVE[y];
  644.                 X=MOVE[x];
  645.                 X=0X00;
  646.                 Z=MOVE[z];
  647.                 Delay(200);
  648.                 for(i=0;i<z+1;i++)
  649.                 {
  650.                         Z|=MOVE[z]>>i;;
  651.                         Delayms(t);
  652.                 }
  653.                 for(i=0;i<z+1;i++)
  654.                 {
  655.                         Z=ADD_Y[z]>>i;
  656.                         Delayms(t-20);
  657.                 }
  658.         }
  659. }


  662. void LOG1()
  663. {
  664.         uint8 i,d;
  665.         for(i=0;i<35;i++)
  666.         {
  667.                 CLEAR();
  668.                 Z = 0xff;
  669.                 Delayms(2);
  670.                 for(d=0;d<30;d++)
  671.                 LOG1h(i);
  672.         }                  
  673. }
  674. void LOG2(uint8 x,uint8 y)//烟花
  675. {
  676.         int8 i,z,k,f;
  677.         uint8 LO[8]={0x38,0x7c,0xfe};
  678.         uint8 LI[8]={0x28,0x44,0x82};                                  
  679.         CLEAR();   

  681.     for(f=0;f<2;f++)
  682.     {
  683.       for(z=0;z<8;z++)
  684.       {
  685.         for(i=0;i<30;i++)
  686.             {
  687.             Y = 0x00;
  688.             X = 0xff;     
  689.             X = 0x00;   
  690.                         Y = MOVE[y];
  691.                         X = MOVE[x];
  692.                         X = 0X00;     
  693.                     if(f == 0)
  694.                         {
  695.               Z = ADD_Y[z]; //设置Z轴坐标
  696.                     }
  697.                         if(f == 1)
  698.                     {
  699.                           Z = ~ADD_Y[z]; //设置X轴坐
  700.             }     
  701.                    Delayms(2+2*f);
  702.           }
  703.             }
  704.       }       
  705.    

  707.     for(f=0;f<2;f++)
  708.     {
  709.       for(i=0;i<127;i++)
  710.       {   
  711.           Y = 0x10; //设置X轴坐标
  712.                   X = 0X10;  
  713.           Z = 0x80; //设置Y轴坐标                  
  714.                  Delayms(2);
  715.         
  716.       }
  717.     }
  718.          
  719.          

  721. for(f=0;f<2;f++)
  722.     {
  723.       for(k=0;k<3;k++)
  724.       {
  725.         for(i=0;i<85;i++)
  726.             {
  727.             Y = 0x00;
  728.             X = 0xff;     
  729.             X = 0x00;
  730.                         Y = MOVE[y];     
  731.                     if(f == 0)
  732.                         {
  733.               X = LO[k]; //设置X轴坐标
  734.                           X = 0x00;
  735.                     }
  736.                         if(f == 1)
  737.                     {
  738.                           X = ~LO[k]; //设置X轴坐
  739.                           X = 0x00;
  740.             }
  741.                         Z = 0X80 ;
  742.                             
  743.                     if(f == 0)
  744.                         {
  745.               Y = LO[k]; //设置X轴坐标
  746.                     }
  747.                         if(f == 1)
  748.                     {
  749.                           Y = ~LO[k]; //设置X轴坐
  750.             }
  751.                         X = MOVE[x];
  752.                         X = 0X00;
  753.                         Z = 0X80 ;
  754.                        
  755.                         if(f == 0)
  756.                         {
  757.               Y = LI[k];
  758.                           X = LI[k];//设置X轴坐标
  759.                           X = 0X00;
  760.                     }
  761.                         if(f == 1)
  762.                         {
  763.               Y = LI[k-1];
  764.                           X = LI[k-1];//设置X轴坐标
  765.                                  X = 0X00;
  766.                         }
  767.                         Z = 0X80;        
  768.                             
  769.                    Delayms(2+2*f);
  770.                        
  771.           }
  772.             }
  773.       }

  775.     for(f=0;f<2;f++)
  776.     {
  777.       for(z=0;z<8;z++)
  778.       {
  779.         for(i=0;i<100;i++)
  780.             {
  781.             Y = 0x00;
  782.             X = 0xff;     
  783.             X = 0x00;   
  784.                         Y = 0x81|MOVE[y];
  785.                         X = 0x81|MOVE[x];
  786.                         X = 0X00;     
  787.                     if(f == 0)
  788.                         {
  789.               Z = ~ADD_Y[7-z]; //设置Z轴坐标
  790.                     }
  791.                         if(f == 1)
  792.                     {
  793.                           Z = ADD_Y[7-z]; //设置X轴坐
  794.             }     
  795.                    Delayms(2+2*f);
  796.           }
  797.             }
  798.       }       
  799.    

  801.     for(f=0;f<2;f++)
  802.     {
  803.       for(i=0;i<100;i++)
  804.       {   
  805.           Y = 0x81|MOVE[y]; //设置X轴坐标
  806.                   X = 0x81|MOVE[x];  
  807.           Z = 0x01; //设置Y轴坐标                  
  808.                  Delayms(2);
  809.         
  810.       }
  811.     }
  812. }

  814. void FIRE(uchar x,uchar y)
  815. {
  816.         uchar i,j,z;
  817.        
  818.         CLEAR();
  819.         Y=MOVE[y];
  820.         X=MOVE[x];
  821.         X=0x00;
  822.         Z=0x80;
  823.        
  824.         for(z=0;z<8;z++)
  825.         {
  826.                 Z=0x01<<z;
  827.                 Delayms(120*z);//减速上升
  828.         }

  830.         for(i=0;i<3;i++)//爆开3圈范围内
  831.         {       
  832.                 CLEAR();
  833.                 Y=MOVE[y]>>i;//横竖方向
  834.                 X=MOVE[x]>>i;
  835.                 Y|=MOVE[y]<<i;
  836.                 X|=MOVE[x]<<i;
  837.                 X=0x00;
  838.                 Z=0x80;
  839.                
  840.                 Y=MOVE[y]>>(i+1);//斜线方向
  841.                 Y|=MOVE[y]<<(i+1);//向外爆两格
  842.                 X|=MOVE[x];
  843.                 X=0x00;
  844.                 Z=0x80;

  846.                 Y=MOVE[y];
  847.                 X=MOVE[x]>>(i+1);
  848.                 X|=MOVE[x]<<(i+1);
  849.                 X=0x00;
  850.                 Z=0x80;

  852.                 Delayms(300);
  853.         }


  856.     for(j=0;j<2;j++)//下落
  857.     {
  858.       for(z=0;z<8;z++)
  859.       {
  860.         for(i=0;i<30;i++) //持续
  861.             {   
  862.                     if(j == 0)
  863.                         {
  864.               Z = ADD_X[z]; //设置Z轴
  865.                     }
  866.                         if(j == 1)
  867.                     {
  868.                           Z = ~ADD_X[z]; //设置X轴
  869.             }     
  870.                    Delayms(8+2*j);
  871.           }
  872.             }
  873.       }       
  874. }

  876. void LOG1h(uint8 i)
  877. {       
  878.         uint8 BOOT[] = {0x18,0x24,0x42,0x81,
  879.                                         0x82,0x84,0X88,0x90,0XA0,0XC0,
  880.                                         0XA0,0x90,0X88,0x84,0x82,0x81,
  881.                                         0X41,0X21,0X11,0X09,0X05,0X03,
  882.                                         0X05,0X09,0X11,0X21,0X41,0X81,
  883.                                         0x42,0x24,0x18,0X3C,0x66,0xc3,0x81};
  884.           uint8 BOOT1[] = {0x00,0x18,0x3c,0x7e,
  885.                                         0x7c,0x78,0x70,0x60,0X40,0X00,
  886.                                         0X40,0X60,0x70,0X78,0X7C,0X7E,
  887.                                         0X3E,0X1E,0X0E,0X06,0X02,0X00,
  888.                                         0X02,0X06,0X0E,0X1E,0X3E,0X7E,
  889.                                         0x3c,0x18,0x00,0x00,0X00,0x00,0x00};
  890.         Y = BOOT[i];
  891.         X = BOOT[i];   
  892.         X = 0x00;
  893.         Z = BOOT[i];
  894.         Delayms(5);
  895.         Y = BOOT[i];
  896.         X = BOOT1[i];   
  897.         X = 0x00;
  898.         Z = BOOT1[i];
  899.         Delayms(5);
  900.         Y = BOOT1[i];
  901.         X = BOOT[i];   
  902.         X = 0x00;
  903.         Z = BOOT1[i];
  904.         Delayms(5);
  905.         Y = BOOT1[i];
  906.         X = BOOT1[i];   
  907.         X = 0x00;
  908.         Z = BOOT[i];
  909.         Delayms(5);
  910.         Y = BOOT[i];
  911.         X = BOOT1[i];   
  912.         X = 0x00;
  913.         Z = BOOT[i];
  914.         Delayms(5);
  915. }

  917. /*********************************************************************************************
  918. 函数名：图形7
  919. 调  用：CUBE_LOG7 ();
  920. //CUBD_LOG7(CHAR_GLF,24);//光立方
  921. 结  果：显示流动字符：
  922. /*********************************************************************************************/
  923. void CUBE_LOG7(uint8 *DAT,uint8 num)
  924. {
  925.         int8 x,y,z=0;
  926.         int16 i,d;
  927.        
  928.         for(i=0;i<num+22;i++)
  929.         {
  930.                 for(d=0;d<10;d++)
  931.                 {
  932.                         z = i;
  933.                         Y = 0x80;    //设置Y轴坐标
  934.                         X = 0xff;    //设置X轴坐标   
  935.                         X = 0x00;
  936.                         for(x=0;x<8;x++)
  937.                         {
  938.                                 Y = 0x00;    //设置Y轴坐标
  939.                                 X = 0xff;    //设置X轴坐标   
  940.                                 X = 0x00;    //锁存X轴坐标
  941.                                 Z = DAT[z++];//锁存X轴坐标
  942.                                 Y = 0x80;         //设置Y轴坐标
  943.                                 X = MOVE[x]; //设置X轴坐标   
  944.                                 X = 0x00;    //锁存X轴坐标
  945.                                 Delayms(3);
  946.                         }
  947.                        
  948.                         Y = 0x80;    //设置Y轴坐标
  949.                         X = 0xff;    //设置X轴坐标   
  950.                         X = 0x00;    //锁存X轴坐标   
  951.                        
  952.                         for(y=0;y<8;y++)  
  953.                         {   
  954.                                 Z = DAT[z++];//锁存X轴坐标
  955.                                 Y = MOVE[y]; //设置Y轴坐标
  956.                                 X = 0x01;
  957.                                 X = 0X00; //设置X轴坐标   
  958.                                 Delayms(3);
  959.                         }
  960.                        
  961.                         for(x=7;x>=0;x--)
  962.                         {
  963.                                 Y = 0x00;    //设置Y轴坐标
  964.                                 X = 0xff;    //设置X轴坐标   
  965.                                 X = 0x00;    //锁存X轴坐标
  966.                                 Z = DAT[z++]; //锁存X轴坐标
  967.                                 Y = 0x10; //设置Y轴坐标
  968.                                 X = MOVE[x]; //设置X轴坐标   
  969.                                 X = 0x00;    //锁存X轴坐标
  970.                                 Delayms(3);
  971.                         }
  972.                 }
  973.         }         
  974. }        
  975. /*********************************************************************************************
  976. 函数名：图形9
  977. 调  用：CUBE_LOG9 ();
  978. 结  果：雨帘
  979. /*********************************************************************************************/
  980. void CUBE_LOG9()
  981. {
  982.         int x,z,i,d,k,a;

  984.         Z = 0x00; //熄灭所有LED

  986.         for(a=0;a<2;a++)
  987.         {
  988.                 for(k=0;k<2;k++)
  989.                 {
  990.                         Y = 0x00;    //设置Y轴坐标
  991.                         X = 0xff;    //设置X轴坐标   
  992.                         X = 0x00;    //锁存X轴坐标
  993.                         Y = 0xff;   //设置Y轴坐标

  995.                         for(i=0;i<8;i++)
  996.                         {
  997.                                 for(d=0;d<5;d++)
  998.                                 {
  999.                                         z=0;
  1000.                                         Y = 0x00;    //设置Y轴坐标
  1001.                                         X = 0xff;    //设置X轴坐标   
  1002.                                         X = 0x00;    //锁存X轴坐标
  1003.                                         Y = 0xff;    //设置Y轴坐标
  1004.                                         for(z=0;z<8-i;z++)
  1005.                                         {
  1006.                                                 Z = 0x01<<z;  //锁存X轴坐标
  1007.                                                 if(k == 0)
  1008.                                                         X = 0x01;      //设置X轴坐标   
  1009.                                                 if(k == 1)
  1010.                                                         X = 0x80;      //设置X轴坐标
  1011.                                                 Delayms(5);   
  1012.                                         }
  1013.                                        
  1014.                                         for(x=0;x<i;x++)
  1015.                                         {
  1016.                                                 Y = 0x00;    //设置Y轴坐标
  1017.                                                 X = 0xff;    //设置X轴坐标   
  1018.                                                 X = 0x00;    //锁存X轴坐标
  1019.                                                 Y = 0xff;    //设置Y轴坐标

  1021.                                                 Z = 0x01<<(8-i+x);  //锁存X轴坐标
  1022.                                                 if(k == 0)
  1023.                                                         X = 0x01<<(x+1);      //设置X轴坐标  
  1024.                                                 if(k == 1)
  1025.                                                         X = 0x80>>(x+1);      //设置X轴坐标  
  1026.                                                 Delayms(5);   
  1027.                                         }  
  1028.                                 }
  1029.                         }       

  1031.                        
  1032.                         Y = 0x00;    //设置Y轴坐标
  1033.                         X = 0xff;    //设置X轴坐标   
  1034.                         X = 0x00;    //锁存X轴坐标
  1035.                         Y = 0xff;    //设置Y轴坐标

  1037.                         for(i=7;i>=0;i--)
  1038.                         {
  1039.                                 for(d=0;d<5;d++)
  1040.                                 {
  1041.                                         z=0;
  1042.                                         for(z=0;z<i;z++)
  1043.                                         {
  1044.                                                 Y = 0x00;    //设置Y轴坐标
  1045.                                                 X = 0xff;    //设置X轴坐标   
  1046.                                                 X = 0x00;    //锁存X轴坐标
  1047.                                                 Y = 0xff;    //设置Y轴坐标
  1048.                                                 if(k == 0)
  1049.                                                 {
  1050.                                                         Z = 0x01<<z;       //锁存X轴坐标
  1051.                                                         X = MOVE[7-i]<<z;  //设置X轴坐标  
  1052.                                                 }
  1053.                                                 if(k == 1)
  1054.                                                 {
  1055.                                                         Z = 0x01<<z;       //锁存X轴坐标
  1056.                                                         X = MOVE[i]>>z;    //设置X轴坐标
  1057.                                                 }
  1058.                                                 Delayms(5);   
  1059.                                         }  

  1061.                                         for(x=i;x<8;x++)
  1062.                                         {
  1063.                                                 Y = 0x00;    //设置Y轴坐标
  1064.                                                 X = 0xff;    //设置X轴坐标   
  1065.                                                 X = 0x00;    //锁存X轴坐标
  1066.                                                 Y = 0xff;    //设置Y轴坐标

  1068.                                                 if(k == 0)
  1069.                                                 {
  1070.                                                         Z = 0x01<<x;  //锁存X轴坐标                  
  1071.                                                         X = 0x80;     //设置X轴坐标   
  1072.                                                 }
  1073.                                                 if(k == 1)
  1074.                                                 {
  1075.                                                         Z = 0x01<<x;  //锁存X轴坐标       
  1076.                                                         X = 0x01;     //设置X轴坐标
  1077.                                                 }  
  1078.                                                 Delayms(5);   
  1079.                                         }  
  1080.                                 }
  1081.                         }       
  1082.                 }
  1083.         }  Z = 0x00;

  1085.         Y = 0xff; //设置Y轴坐标
  1086.         X = 0x01; //设置X轴坐标   
  1087.         X = 0x00; //锁存X轴坐标
  1088.         Z = 0xff; //(0,7,z)轴上的LED
  1089.                 for(a=0;a<2;a++)
  1090.         {
  1091.                 for(x=0;x<8;x++)
  1092.                 {
  1093.                         Y = 0x00; //设置Y轴坐标
  1094.                         X = 0xff; //设置X轴坐标   
  1095.                         X = 0x00; //锁存X轴坐标

  1097.                         Y = 0xff; //设置Y轴坐标
  1098.                         X = 0x01<<x; //设置X轴坐标           
  1099.                         X = 0x00; //锁存X轴坐标
  1100.                         Delayms(300);
  1101.                 }

  1103.                 for(x=0;x<8;x++)
  1104.                 {
  1105.                         Y = 0x00; //设置Y轴坐标
  1106.                         X = 0xff; //设置X轴坐标   
  1107.                         X = 0x00; //锁存X轴坐标

  1109.                         Y = 0xff; //设置Y轴坐标
  1110.                         X = 0x80>>x; //设置X轴坐标           
  1111.                         X = 0x00; //锁存X轴坐标
  1112.                         Delayms(300);
  1113.                 }
  1114.         }
  1115. }
  1116. /*********************************************************************************************
  1117. 函数名：图形10
  1118. 调  用：CUBE_LOG10 ();
  1119. 结  果：音乐律动
  1120. /*********************************************************************************************/
  1121. void CUBE_LOG10()
  1122. {
  1123.         int8 f,d,k,j;

  1125.         uint8 FACE_Y1[] = {0x81,0x42,0x24,0x18};
  1126.         uint8 FACE_Z1[] = {0xff,0x7e,0x3c,0x18};
  1127.         uint8 FACE_Y2[] = {0x7e,0x3c,0x18,0x00};
  1128.         uint8 FACE_Z2[] = {0x81,0x42,0x24,0x18};
  1129.         uint8 FACE_X[]  = {0,1,2,3};

  1131.         Z = 0x00; //熄灭所有LED   
  1132.         Y = 0x00; //设置Y轴坐标
  1133.         X = 0xff; //设置X轴坐标   
  1134.         X = 0x00; //锁存X轴坐标

  1136.         for(j=0;j<2;j++)
  1137.         for(k=0;k<30;k++)
  1138.         {
  1139.                 switch(k)
  1140.                 {
  1141.                 case 0:  FACE_X[0]=0;FACE_X[1]=0;FACE_X[2]=0;FACE_X[3]=0;break;
  1142.                 case 1:  FACE_X[0]=1;FACE_X[1]=1;FACE_X[2]=1;FACE_X[3]=1;break;
  1143.                 case 2:  FACE_X[0]=2;FACE_X[1]=2;FACE_X[2]=2;FACE_X[3]=2;break;
  1144.                 case 3:  FACE_X[0]=3;FACE_X[1]=3;FACE_X[2]=3;FACE_X[3]=3;break;
  1145.                 case 4:  FACE_X[0]=4;FACE_X[1]=4;FACE_X[2]=4;FACE_X[3]=4;break;
  1146.                 case 5:  FACE_X[0]=4;FACE_X[1]=4;FACE_X[2]=4;FACE_X[3]=5;break;
  1147.                 case 6:  FACE_X[0]=4;FACE_X[1]=4;FACE_X[2]=5;FACE_X[3]=6;break;
  1148.                 case 7:  FACE_X[0]=4;FACE_X[1]=5;FACE_X[2]=6;FACE_X[3]=7;break;
  1149.                 case 8:  FACE_X[0]=4;FACE_X[1]=4;FACE_X[2]=5;FACE_X[3]=6;break;
  1150.                 case 9:  FACE_X[0]=4;FACE_X[1]=4;FACE_X[2]=4;FACE_X[3]=5;break;
  1151.                 case 10: FACE_X[0]=4;FACE_X[1]=4;FACE_X[2]=4;FACE_X[3]=4;break;
  1152.                 case 11: FACE_X[0]=4;FACE_X[1]=4;FACE_X[2]=4;FACE_X[3]=3;break;
  1153.                 case 12: FACE_X[0]=4;FACE_X[1]=4;FACE_X[2]=3;FACE_X[3]=2;break;
  1154.                 case 13: FACE_X[0]=4;FACE_X[1]=3;FACE_X[2]=2;FACE_X[3]=1;break;
  1155.                 case 14: FACE_X[0]=4;FACE_X[1]=4;FACE_X[2]=3;FACE_X[3]=2;break;
  1156.                 case 15: FACE_X[0]=4;FACE_X[1]=4;FACE_X[2]=4;FACE_X[3]=3;break;
  1157.                 case 16: FACE_X[0]=4;FACE_X[1]=4;FACE_X[2]=4;FACE_X[3]=4;break;
  1158.                 case 17: FACE_X[0]=4;FACE_X[1]=4;FACE_X[2]=4;FACE_X[3]=5;break;
  1159.                 case 18: FACE_X[0]=4;FACE_X[1]=4;FACE_X[2]=5;FACE_X[3]=6;break;
  1160.                 case 19: FACE_X[0]=4;FACE_X[1]=5;FACE_X[2]=6;FACE_X[3]=7;break;
  1161.                 case 20: FACE_X[0]=5;FACE_X[1]=5;FACE_X[2]=6;FACE_X[3]=7;break;
  1162.                 case 21: FACE_X[0]=6;FACE_X[1]=6;FACE_X[2]=6;FACE_X[3]=7;break;
  1163.                 case 22: FACE_X[0]=7;FACE_X[1]=7;FACE_X[2]=7;FACE_X[3]=7;break;
  1164.                 case 23: FACE_X[0]=6;FACE_X[1]=6;FACE_X[2]=6;FACE_X[3]=6;break;
  1165.                 case 24: FACE_X[0]=5;FACE_X[1]=5;FACE_X[2]=5;FACE_X[3]=5;break;
  1166.                 case 25: FACE_X[0]=4;FACE_X[1]=4;FACE_X[2]=4;FACE_X[3]=4;break;
  1167.                 case 26: FACE_X[0]=3;FACE_X[1]=3;FACE_X[2]=3;FACE_X[3]=3;break;
  1168.                 case 27: FACE_X[0]=2;FACE_X[1]=2;FACE_X[2]=2;FACE_X[3]=2;break;
  1169.                 case 28: FACE_X[0]=1;FACE_X[1]=1;FACE_X[2]=1;FACE_X[3]=1;break;
  1170.                 case 29: FACE_X[0]=0;FACE_X[1]=0;FACE_X[2]=0;FACE_X[3]=0;break;
  1171.                 }

  1173.                 for(d=0;d<7;d++)
  1174.                 {
  1175.                         for(f=0;f<4;f++)
  1176.                         {
  1177.                                 CLEAR();

  1179.                                 Y = FACE_Y1[f];  //设置Y轴坐标
  1180.                                 X = MOVE[FACE_X[f]];   //设置X轴坐标   
  1181.                                 X = 0x00;        //锁存X轴坐标
  1182.                                 Z = FACE_Z1[f];  //(0,7,z)轴上的LED
  1183.                                 Delayms(5);

  1185.                                 CLEAR();

  1187.                                 Y = FACE_Y2[f];   //设置Y轴坐标
  1188.                                 X = MOVE[FACE_X[f]];    //设置X轴坐标   
  1189.                                 X = 0x00;         //锁存X轴坐标
  1190.                                 Z = FACE_Z2[f];   //(0,7,z)轴上的LED
  1191.                                 Delayms(5);  
  1192.                         }
  1193.                 }
  1194.         }
  1195. }  
  1196. /*********************************************************************************************
  1197. 函数名：图形11
  1198. 调  用：CUBE_LOG11 ();
  1199. 结  果：逐一轴叠加点亮坐标为(0,y,0~7)点上的一轴LED,其他坐标点上的LED熄灭(左侧面)
  1200. 备  注：竖直表面顺时针环绕
  1201. /*********************************************************************************************/
  1202. void CUBE_LOG11()
  1203. {
  1204.         uint8 i,x,z,k;
  1205.         int16 d;
  1206.        
  1207.         for(k=0;k<3;k++)
  1208.         {
  1209.                 for(i=0;i<8;i++)
  1210.                 {
  1211.                         for(d=0;d<1000;d++)
  1212.                         {
  1213.                                 for(z=i;z<8;z++)
  1214.                                 LED_Y(0,z);
  1215.                
  1216.                                 for(x=1;x<i;x++)
  1217.                                 LED_Y(x,7);
  1218.                         }
  1219.                 }         
  1220.                
  1221.                 for(i=0;i<8;i++)
  1222.                 {
  1223.                         for(d=0;d<1000;d++)
  1224.                         {
  1225.                                 for(x=i;x<8;x++)
  1226.                                 LED_Y(x,7);
  1227.                                 for(z=0;z<i;z++)
  1228.                                 LED_Y(7,7-z);
  1229.                         }
  1230.                 }         
  1231.                
  1232.                 for(i=0;i<8;i++)
  1233.                 {
  1234.                         for(d=0;d<1000;d++)
  1235.                         {
  1236.                                 for(z=i;z<8;z++)
  1237.                                 LED_Y(7,7-z);
  1238.                                 for(x=0;x<i;x++)
  1239.                                 LED_Y(7-x,0);
  1240.                         }
  1241.                 }       
  1242.                
  1243.                 for(i=0;i<8;i++)
  1244.                 {
  1245.                         for(d=0;d<1000;d++)
  1246.                         {
  1247.                                 for(x=i;x<8;x++)
  1248.                                 LED_Y(7-x,0);
  1249.                                 for(z=0;z<i+1;z++)
  1250.                                 LED_Y(0,z);
  1251.                         }
  1252.                 }
  1253.         }
  1254.         Z=0X00;
  1255.         Y=0XFF;
  1256.         X=0X01;
  1257.         X=0X00;
  1258.         Z=0XFF;
  1259.         Delayms(200);       
  1260. }            
  1261. /*********************************************************************************************/

  1263. /*********************************************************************************************
  1264. 函数名：图形12
  1265. 调  用：CUBE_LOG12 ();
  1266. 结  果：逐一轴叠加点亮坐标为(0,y,0~7)点上的一轴LED,其他坐标点上的LED熄灭(左侧面)
  1267. 备  注：横向表面逆时针环绕
  1268. /*********************************************************************************************/
  1269. void CUBE_LOG12()
  1270. {
  1271.         uint8 i,x,y,k;
  1272.         int16 d;
  1273.        
  1274.         for(k=0;k<3;k++)
  1275.         {
  1276.                 for(i=0;i<8;i++)
  1277.                 {
  1278.                         for(d=0;d<1000;d++)
  1279.                         {
  1280.                                 for(y=i;y<8;y++)
  1281.                                 LED_Z(0,7-y);
  1282.                                 for(x=1;x<i;x++)
  1283.                                 LED_Z(x,0);
  1284.                         }
  1285.                 }         
  1286.                
  1287.                 for(i=0;i<8;i++)
  1288.                 {
  1289.                         for(d=0;d<1000;d++)
  1290.                         {
  1291.                                 for(x=i;x<8;x++)
  1292.                                 LED_Z(x,0);
  1293.                                 for(y=0;y<i;y++)
  1294.                                 LED_Z(7,y);
  1295.                         }
  1296.                 }         
  1297.                
  1298.                 for(i=0;i<8;i++)
  1299.                 {
  1300.                         for(d=0;d<1000;d++)
  1301.                         {
  1302.                                 for(y=i;y<8;y++)
  1303.                                 LED_Z(7,y);
  1304.                                 for(x=0;x<i;x++)
  1305.                                 LED_Z(7-x,7);
  1306.                         }
  1307.                 }          
  1308.                
  1309.                 for(i=0;i<8;i++)
  1310.                 {
  1311.                         for(d=0;d<1000;d++)
  1312.                         {
  1313.                                 for(x=i;x<8;x++)
  1314.                                 LED_Z(7-x,7);
  1315.                                 for(y=0;y<i+1;y++)
  1316.                                 LED_Z(0,7-y);
  1317.                         }
  1318.                 }
  1319.         }
  1320.         Y=0XFF;
  1321.         X=0X01;
  1322.         X=0X00;
  1323.         Z=0XFF;
  1324.         Delayms(200);       
  1325. }
  1326. /*********************************************************************************************
  1327. 函数名：点亮某一X轴上的LED
  1328. 调  用：LED_X (?);
  1329. 参  数：
  1330. 结  果：点亮相对应坐标点上的一个LED,其他坐标点上的LED熄灭
  1331. ********************************************************************************************/
  1332. void LED_X(uint8 y, uint8 z)
  1333. {
  1334.         CLEAR();
  1335.         Y=MOVE[y];  //设置Y轴坐标
  1336.         X=0xff;     //锁存X轴坐标
  1337.         X=0x00;     //锁存X轴坐标
  1338.         Z=MOVE[z];  //设置Z轴坐标  
  1339. }  

  1341. /*********************************************************************************************
  1342. 函数名：点亮某一Y轴上的LED
  1343. 调  用：LED_Y (?);
  1344. 结  果：点亮相对应坐标点上的一个LED,其他坐标点上的LED熄灭
  1345. /********************************************************************************************/
  1346. void LED_Y(uint8 x, uint8 z)
  1347. {
  1348.         CLEAR();
  1349.        
  1350.         Y = 0xff;    //设置Y轴坐标
  1351.         X = MOVE[x]; //设置X轴坐标   
  1352.         X = 0x00;    //锁存X轴坐标
  1353.         Z = MOVE[z]; //设置Z轴坐标   
  1354. }  
  1355. /*********************************************************************************************/

  1357. /*********************************************************************************************
  1358. 函数名：同时点亮某一Z轴上的LED
  1359. 调  用：LED_ZWATERWater(?);
  1360. 参  数：x:x轴, y:y轴, z:z轴
  1361. 结  果：点亮相对应坐标点上的一个LED,其他坐标点上的LED熄灭：
  1362. /*********************************************************************************************/
  1363. void LED_Z(uint8 x, uint8 y)
  1364. {
  1365.         //Z = 0x00; //熄灭所有LED   
  1366.         Y = 0x00; //设置Y轴坐标
  1367.         X = 0xff; //设置X轴坐标   
  1368.         X = 0x00; //锁存X轴坐标
  1369.        
  1370.         Y = MOVE[y];    //设置Y轴坐标
  1371.         X = MOVE[x]; //设置X轴坐标   
  1372.         X = 0x00;    //锁存X轴坐标
  1373.         Z = 0xff; //熄灭所有LED   
  1374. }  
  1375. /*********************************************************************************************
  1376. 函数名：依次自下而上减速点亮某Z轴上的LED，
  1377. 调  用：LED_ZWATER (x,y,ms);
  1378. 参  数：x:x轴, y:y轴, z:z轴
  1379. 返回值：无
  1380. 结  果：点亮相对应z坐标轴上的一个LED,其他坐标点上的LED熄灭
  1381. *********************************************************************************************/
  1382. void LED_ZWATER(uint8 x, uint8 y, uint16 speed)
  1383. {
  1384.         uint8 z;
  1385.         uint16 s;
  1386.        
  1387.         for(z=0;z<8;z++)
  1388.         {       
  1389.                 LED_DOT_ON(x,y,z);
  1390.                 s = speed + z*2;
  1391.                 Delayms(s); //延时
  1392.         }
  1393. }
  1394. void LIST_LOG()
  1395. {
  1396.         uint8 z,y;
  1397.        
  1398.         CLEAR();   
  1399.        
  1400.         Y = 0x01; //设置Y轴坐标
  1401.         X = 0x01; //设置X轴坐标   
  1402.         X = 0x00; //锁存X轴坐标
  1403.        
  1404.         for(z=0;z<8;z++)
  1405.         {
  1406.                 Z = 0x80 >>z; //锁存X轴坐标
  1407.                 Delayms(300);
  1408.         }
  1409.         Z=0X01;
  1410.         for(y=0;y<8;y++)
  1411.         {
  1412.                 Y = 0x01 <<y;
  1413.                 X = 0x01; //设置X轴坐标   
  1414.                 X = 0x00; //锁存X轴坐标 //锁存X轴坐标
  1415.                 Delayms(300);
  1416.         }
  1417. }
  1418. void LAST_LOG()
  1419. {
  1420.         uchar i;  
  1421.        
  1422.         Y=0x80; //设置Y轴坐标
  1423.         X=0x80; //设置X轴坐标   
  1424.         X=0x00; //锁存X轴坐标

  1426.         for(i=0;i<8;i++)
  1427.         {       
  1428.                 Z=0x80>>i; //锁存X轴坐标
  1429.                 Delayms(150);
  1430.         }
  1431.         for(i=0;i<8;i++)
  1432.         {       
  1433.                 CLEAR();
  1434.                 Y=0x80; //设置Y轴坐标
  1435.                 X=0x80>>i; //锁存X轴坐标
  1436.                 X=0X00;
  1437.                 Z=0x01;
  1438.                 Delayms(150);
  1439.         }
  1440. }


  1443. void LOG15()
  1444. {
  1445.         uint i;
  1446.         Y=0XFF;
  1447.         X=0X01;
  1448.         X=0;
  1449.         for(i=0;i<7;i++)
  1450.         {
  1451.                 Z =ADD_Y[i]; //(0,7,z)轴上的LED
  1452.                 Delayms(400);
  1453.         }
  1454.        
  1455. }
  1456. void LOG16()
  1457. {

  1459.                 Y=0xff;
  1460.                 X=0xff;
  1461.                 X=0x00;
  1462.                 Z=0xff;
  1463.                 Delayms(2000);
  1464.                 Z=0x00;
  1465.                 Delayms(200);       
  1466. }
  1467. void LOG17()
  1468. {       
  1469.         uint i;
  1470.         Y=0xff;
  1471.         X=0xff;
  1472.         X=0x00;
  1473.         for(i=0;i<7;i++)
  1474.         {
  1475.                 Z =ADD_Y[i]; //(0,7,z)轴上的LED
  1476.                 Delayms(400);
  1477.         }               
  1478. }
  1479. void LOG18()
  1480. {
  1481.         uint i;
  1482.         Y=0xff;
  1483.         X=0xff;
  1484.         X=0x00;
  1485.         for(i=0;i<7;i++)
  1486.         {
  1487.                 Z =ADD_X[i]; //
  1488.                 Delayms(400);
  1489.         }                               
  1490. }  
  1491. void LOG19()
  1492. {
  1493.         uint i;
  1494.         Z=0X01;
  1495.         X=0X01;
  1496.         for(i=0;i<8;i++)
  1497.                 {Y=ADD_Y[i];
  1498.                         Delayms(200);}
  1499.         CLEAR();
  1500.         Y=0XFF;
  1501.         X=0X01;
  1502.         X=0X00;
  1503.         for(i=0;i<8;i++)
  1504.                 {Z=ADD_Y[i];
  1505.                         Delayms(200);        }
  1506. }
  1507. void LOG21()
  1508. {                                uint i;
  1509.                                 Y=0XFF;
  1510.                                 X=0X01;
  1511.                                 X=0X00;
  1512.                                 for(i=0;i<7;i++)
  1513.                                 {
  1514.                                         Z =ADD_Y[i]; //(0,7,z)轴上的LED
  1515.                                         Delayms(600);
  1516.                                 }
  1517.                                 }

  1519. void LOG22()   //雨滴
  1520. {

  1522.         uint16 LOW=0;
  1523.         uint8 d,x,y,z,t,i,T=1500;
  1524.         CLEAR();
  1525.         for(d=0;d<15;d++)
  1526.         {
  1527.                 x=rand()%8;
  1528.                 y=rand()%8;
  1529.                 z=(rand()%4)+4;
  1530.                 t=(rand()%40)+30;       
  1531.                 for(LOW=1;LOW<T;LOW+=10)
  1532.                 {
  1533.                         Y=MOVE[y];
  1534.                         X=MOVE[x];
  1535.                         X=0X00;
  1536.                         Z=MOVE[z];
  1537.                         Delay(LOW);
  1538.                         CLEAR();
  1539.                         Delay(T-LOW);
  1540.                 }
  1541.                 Y=MOVE[y];
  1542.                 X=MOVE[x];
  1543.                 X=0X00;
  1544.                 Z=MOVE[z];
  1545.                 Delay(200);
  1546.                 for(i=0;i<z+1;i++)
  1547.                 {
  1548.                         Z|=MOVE[z]>>i;;
  1549.                         Delayms(t);
  1550.                 }
  1551.                 for(i=0;i<z+1;i++)
  1552.                 {
  1553.                         Z=ADD_Y[z]>>i;
  1554.                         Delayms(t-20);
  1555.                 }
  1556.                 for(i=0;i<3;i++)//爆开3圈范围内
  1557.         {       
  1558.                 CLEAR();
  1559.                 Y=MOVE[y]>>i;//横竖方向
  1560.                 X=MOVE[x]>>i;
  1561.                 Y|=MOVE[y]<<i;
  1562.                 X|=MOVE[x]<<i;
  1563.                 X=0x00;
  1564.                 Z=0x01;
  1565.                
  1566.                 Y=MOVE[y]>>(i+1);//斜线方向
  1567.                 Y|=MOVE[y]<<(i+1);//向外爆两格
  1568.                 X|=MOVE[x];
  1569.                 X=0x00;
  1570.                 Z=0x01;

  1572.                 Y=MOVE[y];
  1573.                 X=MOVE[x]>>(i+1);
  1574.                 X|=MOVE[x]<<(i+1);
  1575.                 X=0x00;
  1576.                 Z=0x01;

  1578.                 Delayms(300);
  1579.         }
  1580.         }
  1581. }
  1582. void LOG23()//音柱       
  1583. {
  1584.         uint8 z,i,k;
  1585.         uint16 d;
  1586.         uint8 CD[]={0xff,0xff,0xff,
  1587.                                 0X0f,0Xf0,0x00,
  1588.                                 0X03,0xc0,0X18,
  1589.                                 0xe7,0xe7,0x00,
  1590.                                 0xc3,0xc3,0x18,
  1591.                                 0xc3,0x30,0x0c,
  1592.                                 0xdb,0xdb,0xdb,
  1593.                                 0xaa,0xaa,0xaa,
  1594.                                 0x49,0x49,0x49,};

  1596.         for(i=0;i<27;i=i+3)
  1597.         {
  1598.                 for(k=0;k<8;k++)
  1599.                 {
  1600.                         Y = 0x00; //设置Y轴坐标
  1601.                         X = 0xff; //设置X轴坐标   
  1602.                         X = 0x00; //锁存X轴坐标
  1603.                         Z = 0x00; //熄灭所有LED

  1605.                         for(z=0;z<8;z++)
  1606.                         {
  1607.                                 Y = CD[i]; //设置Y轴坐标
  1608.                                 X = CD[i]; //设置X轴坐标   
  1609.                                 X = 0x00; //锁存X轴坐标
  1610.                                 Z |= 0x01 <<z; //锁存X轴坐标
  1611.                                 Y = CD[i+1]; //设置Y轴坐标
  1612.                                 X = CD[i+1]; //设置X轴坐标   
  1613.                                 X = 0x00; //锁存X轴坐标
  1614.                                 Z |= 0x01 <<z; //锁存X轴坐标
  1615.                                 //         if(i%2==1)
  1616.                                 {
  1617.                                         Y = CD[i+2]; //设置Y轴坐标
  1618.                                         X = CD[i+2]; //设置X轴坐标   
  1619.                                         X = 0x00; //锁存X轴坐标
  1620.                                         Z |= 0x01 <<z; //锁存X轴坐标       
  1621.                                 }                                                         
  1622.                                 d = 45535;
  1623.                                 while(d) d--;
  1624.                         }
  1625.                 }
  1626.                 Y = 0x00; //设置Y轴坐标
  1627.                 X = 0xff; //设置X轴坐标   
  1628.                 X = 0x00; //锁存X轴坐标
  1629.                 Z = 0x00; //熄灭所有LED
  1630.         }
  1631. }         
  1632. void LOG24()
  1633. {
  1634.                                
  1635.         uint i;
  1636.         Z=0XFF;
  1637.         X=0Xff;
  1638.          for(i=0;i<9;i++)
  1639.          {
  1640.                 Y=ADD_M[i];       
  1641.                 Delayms(500);
  1642.                 }       
  1643.          CLEAR();
  1644.          Z=0XFF;
  1645.         X=0Xff;
  1646.          for(i=9;i>0;i--)
  1647.          {
  1648.                 Y=ADD_M[i-1];       
  1649.                 Delayms(500);
  1650.                 }       
  1651.          CLEAR();
  1652.        
  1653. }

  1655. void LOG25()
  1656. {
  1657.         uint i;
  1658.         Y=0XFF;
  1659.         X=0Xff;
  1660.         X=0X00;
  1661.         for(i=7;i>0;i--)
  1662.         {
  1663.                 Z =ADD_Y[i-1]; //(0,7,z)轴上的LED
  1664.                 Delayms(600);
  1665.         }
  1666.         CLEAR();       
  1667. }


  1670. void zhen(uchar *a,uchar v)//一帧,a是一帧编码起始地址
  1671. {
  1672. uchar p;
  1673. char i;
  1674. while(v--)
  1675. {
  1676.   p=1;
  1677.   for(i=0;i<8;i++)
  1678.   {
  1679.    P0=0;
  1680.    fun(a+i*8);
  1681.    P0=p;
  1682.    Delayms(2);
  1683.    p<<=1;
  1684.   }
  1685. }
  1686. }
  1687. void zhen_1(uchar *a,uchar v)//一帧,a是一帧编码起始地址
  1688. {
  1689. uchar p;
  1690. char i;
  1691. while(v--)
  1692. {
  1693.   p=1;
  1694.   for(i=0;i<8;i++)
  1695.   {
  1696.    
  1697.    fun(a+i*8);
  1698.    P0=p;
  1699.    Delayms(10);
  1700.    p<<=1;
  1701.   }
  1702. } P0=0;
  1703. }
  1704. void move(uchar *a,char kind,char direction,char length)//length不能为8
  1705. //kind=0 x轴,1 x轴,2 z轴；direction=0,负向,1正向
  1706. {
  1707. char i,j;
  1708. if(kind==0)
  1709. {
  1710.   if(direction==1)
  1711.    for(i=0;i<64;i++)
  1712.     a[i]<<=length;
  1713.   else
  1714.    for(i=0;i<64;i++)
  1715.     a[i]>>=length;
  1716. }
  1717. else if(kind==1)
  1718. {
  1719.   if(direction==1)
  1720.    for(j=0;j<8;j++)
  1721.    {
  1722.     for(i=7;i>=length;i--)
  1723.      a[i+j*8]=a[i-length+j*8];
  1724.     for(i=0;i<length;i++)
  1725.      a[i+j*8]=0;   
  1726.    }
  1727.   else
  1728.    for(j=0;j<8;j++)
  1729.    {
  1730.     for(i=0;i<length;i++)
  1731.      a[i+j*8]=a[i+length+j*8];
  1732.     for(i=(8-length);i<8;i++)
  1733.      a[i+j*8]=0;   
  1734.    }   
  1735. }
  1736. else
  1737. {
  1738.   if(direction==1)
  1739.    for(j=0;j<8;j++)
  1740.    {
  1741.     for(i=7;i>=length;i--)
  1742.      a[j+i*8]=a[j+(i-length)*8];
  1743.     for(i=0;i<length;i++)
  1744.      a[j+i*8]=0;   
  1745.    }
  1746.   else
  1747.    for(j=0;j<8;j++)
  1748.    {
  1749.     for(i=0;i<(8-length);i++)
  1750.      a[j+i*8]=a[j+(i+length)*8];
  1751.     for(i=(8-length);i<8;i++)
  1752.      a[j+i*8]=0;   
  1753.    }
  1754. }
  1755. }
  1756. void fun(uchar *a)//层填充函数
  1757. {
  1758. uchar i,p;
  1759. p=1;
  1760. for(i=0;i<8;i++)
  1761. {
  1762.   P1=p;
  1763.   P2=a[i];
  1764.   P1=0;
  1765.   p<<=1;
  1766. }
  1767. }
  1768. void qumianxuanzhuan(char kind,char num,char v)//曲面旋转
  1769. {
  1770. uchar a[64]={0};
  1771. char i,j,k;
  1772. for(j=0;j<8;j++)
  1773.   for(i=0;i<8;i++)
  1774.    a[i+j*8]=tab_xuanzhuantiao[i];
  1775. zhen(a,v);
  1776. if(kind==1)
  1777. {
  1778.   for(j=1;j<8;j++)//顺时针初形变换
  1779.   {
  1780.    for(i=0;i<j;i++)
  1781.     for(k=0;k<8;k++)
  1782.      a[k+i*8]=tab_xuanzhuantiao[(j-i)*8+k];
  1783.    zhen(a,v);
  1784.   }
  1785.   for(i=8;i<14;i++)
  1786.   {
  1787.    move(a,2,1,1);
  1788.    for(j=0;j<8;j++)
  1789.     a[j]=tab_xuanzhuantiao[i*8+j];
  1790.    zhen(a,v);
  1791.   }
  1792. }
  1793. else
  1794. {
  1795.   for(j=1;j<8;j++)//逆时针初形变换
  1796.   {
  1797.    for(i=0;i<j;i++)
  1798.     for(k=0;k<8;k++)
  1799.      a[k+i*8]=tab_xuanzhuantiao[(14-j+i)*8+k];
  1800.    zhen(a,v);
  1801.   }
  1802.   for(i=7;i>=0;i--)
  1803.   {
  1804.    move(a,2,1,1);
  1805.    for(j=0;j<8;j++)
  1806.     a[j]=tab_xuanzhuantiao[i*8+j];
  1807.    zhen(a,v);
  1808.   }
  1809. }

  1811. while(num--)//主循环
  1812. {
  1813.   if(kind==1)
  1814.    for(i=0;i<14;i++)
  1815.    {
  1816.     move(a,2,1,1);
  1817.     for(j=0;j<8;j++)
  1818.      a[j]=tab_xuanzhuantiao[i*8+j];
  1819.     zhen(a,v);
  1820.    }
  1821.   else
  1822.    for(i=13;i>=0;i--)
  1823.    {
  1824.     move(a,2,1,1);   
  1825.     for(j=0;j<8;j++)
  1826.      a[j]=tab_xuanzhuantiao[i*8+j];
  1827.     zhen(a,v);
  1828.    }
  1829. }
  1830. if(kind==1)
  1831.   for(j=0;j<7;j++)
  1832.   {
  1833.    for(i=7;i>=j;i--)
  1834.    {
  1835.     if(i>j)
  1836.      for(k=0;k<8;k++)
  1837.       a[k+i*8]=tab_xuanzhuantiao[(14-i+j)*8+k];
  1838.     else
  1839.      for(k=0;k<8;k++)
  1840.       a[k+i*8]=tab_xuanzhuantiao[k];
  1841.    }
  1842.    zhen(a,v);
  1843.   }
  1844. else
  1845.   for(j=1;j<7;j++)
  1846.   {
  1847.    for(i=7;i>=j;i--)
  1848.    {
  1849.     if(i>j)
  1850.      for(k=0;k<8;k++)
  1851.       a[k+i*8]=tab_xuanzhuantiao[(i-j)*8+k];
  1852.     else
  1853.      for(k=0;k<8;k++)
  1854.       a[k+i*8]=tab_xuanzhuantiao[k];
  1855.    }
  1856.    zhen(a,v);
  1857.   }
  1858. }
  1859. void qumianxuanzhuan2(char num,char v)//曲面旋转
  1860. {
  1861. uchar a[64]={0};
  1862. char i,j,k;
  1863. for(j=0;j<8;j++)
  1864.   for(i=0;i<8;i++)
  1865.    a[i+j*8]=tab_xuanzhuantiao[i];
  1866. zhen(a,v);
  1867. for(j=1;j<8;j++)
  1868. {
  1869.   for(i=0;i<j;i++)
  1870.    for(k=0;k<8;k++)
  1871.     a[k+i*8]=tab_xuanzhuantiao[(14-j+i)*8+k];
  1872.   zhen(a,v);
  1873. }
  1874. while(num--)
  1875. {
  1876.   for(j=1;j<8;j++)
  1877.   {
  1878.    move(a,2,1,1);
  1879.    for(i=0;i<j;i++)
  1880.    {
  1881.     for(k=0;k<8;k++)
  1882.     {
  1883.      if(j!=7|i!=0)
  1884.       a[i*8+k]=tab_xuanzhuantiao[k+(j+7-i)*8];
  1885.      else
  1886.       a[k]=tab_xuanzhuantiao[k];
  1887.     }
  1888.    }
  1889.    zhen(a,v);
  1890.   }
  1891.   for(j=1;j<8;j++)
  1892.   {
  1893.    move(a,2,1,1);
  1894.    for(i=0;i<j;i++)
  1895.    {
  1896.     for(k=0;k<8;k++)
  1897.      a[i*8+k]=tab_xuanzhuantiao[k+(14-j+i)*8];
  1898.    }
  1899.    zhen(a,v);
  1900.   }
  1901. }
  1902. }
  1903. void xuanzhuantiao(char kind,char num,char v)//空心旋转,kind=1实心,否则空心
  1904. {
  1905. uchar a[64]={0};
  1906. char i,j,k;
  1907. while(num--)
  1908. {
  1909.   for(i=0;i<14;i++)
  1910.   {
  1911.    for(j=0;j<8;j++)
  1912.    {
  1913.     for(k=0;k<8;k++)
  1914.     {
  1915.      if(k>1&&k<6&&j>1&&j<6&&kind!=1)
  1916.       a[k+j*8]=tab_xuanzhuantiao[i*8+k]&0xc3;
  1917.      else
  1918.       a[k+j*8]=tab_xuanzhuantiao[i*8+k];
  1919.     }
  1920.    }
  1921.    zhen(a,v);
  1922.   }
  1923. }
  1924. }

  1926. void flash0(char v)//条状升降
  1927. {
  1928.   char i,j,k;
  1929.   uchar a[64]={0};
  1930.   for(i=7;i>=0;i--)
  1931.   {
  1932.    a[i]=0x01<<i;
  1933.    zhen(a,v+5);
  1934.   }
  1935.   for(i=0;i<7;i++)
  1936.   {
  1937.    for(j=0;j<8;j++)
  1938.     a[j]=flash0__tab[i*8+j];
  1939.    zhen(a,v+5);
  1940.   }
  1941.   for(i=0;i<7;i++)
  1942.   {
  1943.    move(a,2,1,1);
  1944.    zhen(a,v+5);
  1945.   }
  1946. /*  for(i=0;i<64;i++)
  1947.   {
  1948.    if(i>55)
  1949.     a[i]=0xff;
  1950.    else
  1951.     a[i]=0;
  1952.   }*/
  1953.   zhen(a,20);
  1954.   for(i=7;i>=0;i--)//1
  1955.    for(j=6;j>=0;j--)
  1956.    {
  1957.     a[i+j*8]=0xff;
  1958.     a[i+(j+1)*8]=0;
  1959.     zhen(a,v);
  1960.    }
  1961.   zhen(a,27);
  1962.   for(i=7;i>=0;i--)//2
  1963.    for(j=1;j<8;j++)
  1964.    {
  1965.     a[i+j*8]=0xff;
  1966.     a[i+(j-1)*8]=0;
  1967.     zhen(a,v);
  1968.    }
  1969.   zhen(a,27);
  1970.   for(i=7;i>=0;i--)//3
  1971.    for(k=6;k>=0;k--)
  1972.    {
  1973.     for(j=0;j<8;j++)
  1974.     {
  1975.      if(k==0)
  1976.       a[j+k*8]|=(0x80>>(7-i));
  1977.      else
  1978.       a[j+k*8]=(0x80>>(7-i));
  1979.      a[j+(k+1)*8]^=(0x80>>(7-i));
  1980.     }
  1981.     zhen(a,v);
  1982.    }
  1983.   zhen(a,27);
  1984.   for(i=7;i>=0;i--)//4
  1985.    for(k=1;k<8;k++)
  1986.    {
  1987.     for(j=0;j<8;j++)
  1988.     {
  1989.      if(k==7)
  1990.       a[j+k*8]|=(0x80>>(7-i));
  1991.      else
  1992.       a[j+k*8]=(0x80>>(7-i));
  1993.      a[j+(k-1)*8]^=(0x80>>(7-i));
  1994.     }
  1995.     zhen(a,v);
  1996.    }
  1997.   zhen(a,27);
  1998. }
  1999. short sqrt_16( unsigned long M)   
  2000. {
  2001.     unsigned int N,i;
  2002.     unsigned long tmp,ttp;
  2003.     if(M==0)            
  2004.         return 0;
  2005.     N=0;
  2006.     tmp=(M>>30);        
  2007.     M<<=2;
  2008.     if(tmp>1)            
  2009.     {
  2010.         N++;               
  2011.         tmp-=N;
  2012.     }
  2013.     for(i=15;i>0;i--)   
  2014.     {
  2015.         N<<=1;           
  2016.         tmp<<=2;
  2017.         tmp+=(M>>30);  
  2018.         ttp=N;
  2019.         ttp=(ttp<<1)+1;
  2020.         M<<=2;
  2021.         if(tmp>=ttp)   
  2022.         {
  2023.             tmp-=ttp;
  2024.             N++;
  2025.         }      
  2026.     }
  2027.     return N;
  2028. }
  2029. void H_scan(uchar v)
  2030. {
  2031. uchar b[64]={0};
  2032. char i,j;
  2033. for(i=0;i<64;i++)
  2034.   b[i]=0x80;
  2035. for(i=0;i<7;i++)
  2036. {
  2037.   for(j=0;j<64;j++)
  2038.    b[j]>>=1;
  2039.   zhen(b,v);
  2040. }
  2041. }
  2042. void donghua(uchar *tab,uchar num,uchar n,char v)
  2043. {
  2044. char i;
  2045. while(n--)
  2046. {
  2047.   for(i=0;i<num;i++)//清空
  2048.   {
  2049.    zhen(tab+i*64,v);
  2050.   }
  2051. }
  2052. }
  2053. void donghua_1(uchar *tab,uchar num,uchar n,char v)
  2054. {
  2055. char i;
  2056. while(n--)
  2057. {
  2058.   for(i=0;i<num;i++)//清空
  2059.   {
  2060.    zhen_1(tab+i*64,v);
  2061.   }
  2062. }
  2063. }
  2064. void yinchu(uchar *table,char n,char v)
  2065. {
  2066. /****************************
  2067. n为帧数
  2068. ******************************/
  2069. char i,j,k;
  2070. uchar a[64]={0},p;
  2071. for(k=0;k<n;k++)
  2072. {
  2073.   for(i=0;i<8;i++)
  2074.   {
  2075.    p=0xff;
  2076.    for(j=0;j<64;j++)
  2077.    {
  2078.     a[j]=(table[j+k*64]|(0x80>>i))&(p<<(7-i));
  2079.    }
  2080.    zhen(a,v);
  2081.   }
  2082.   zhen(table+k*64,50);
  2083. }

  2085. }
  2086. void link00()
  2087. {
  2088. uchar a[64]={0};
  2089. char i;
  2090. for(i=10;i>7;i--)
  2091. {
  2092.   zhen(bianxing_table+i*64,70);
  2093. }
  2094. produce_cube(a,6);
  2095. move(a,1,1,1);
  2096. move(a,0,1,1);
  2097. zhen(a,110);
  2098. produce_cube(a,8);
  2099. zhen(a,110);
  2100. }
  2101. void produce_cube(uchar *a,char n)//0<=n<=8
  2102. {
  2103. char i,j;
  2104. for(i=0;i<8;i++)
  2105.   for(j=0;j<8;j++)
  2106.   {
  2107.    if(j<n&&i<n)
  2108.     a[j+i*8]=0xff>>(8-n);
  2109.    else
  2110.     a[j+i*8]=0;
  2111.   }
  2112. }

  2114. void hy(uchar *tab,char v)
  2115. {
  2116. uchar a[64]={0};
  2117. char i,j;
  2118. for(i=0;i<8;i++)
  2119.   a[i*8]=tab[i];
  2120. zhen(a,v);
  2121. for(i=1;i<8;i++)
  2122. {
  2123.      for(j=0;j<8;j++)
  2124.       a[i+j*8]=a[i-1+j*8];
  2125.      zhen(a,v);
  2126. }
  2127.         for(i=0;i<7;i++)
  2128. {
  2129.      for(j=0;j<8;j++)
  2130.       a[i+j*8]=0;
  2131.      zhen(a,v);
  2132. }
  2133.         zhen(a,23);
  2134. }
  2135. void leitu(uchar *b,char num,char v)//V>1
  2136. {
  2137. uchar a[64]={0},p;
  2138. char i,j,k,m;
  2139. for(m=0;m<num;m++)
  2140. {
  2141.   for(i=0;i<8;i++)
  2142.    for(k=0;k<8;k++)
  2143.     for(j=0;j<8;j++)
  2144.     {
  2145.      p=b[m*64+i*8+k]&(0x01<<j);
  2146.      if(p)
  2147.      {
  2148.       a[i*8+k]|=p;
  2149.       zhen(a,v);
  2150.      }
  2151.     }
  2152.   zhen(a,60);
  2153.   for(j=0;j<64;j++)
  2154.   {
  2155.    if(!a[j])
  2156.     continue;
  2157.    a[j]=0;
  2158.    zhen(a,v-1);
  2159.   }
  2160.   Delayms(30);
  2161. }
  2162. }
  2163. void zimu(uchar *x,char n,char v,int num)//滚动字幕,num表示循环次数,v表示滚动速度,n字符个数
  2164. {
  2165. char i,j,k;
  2166. uchar xdata a[64]={0},temp0[8],temp1[8],temp2[8],temp3[8],temp[8];
  2167. for(i=0;i<8;i++)
  2168. {
  2169.   temp0[i]=0;
  2170.   temp1[i]=0;
  2171.   temp2[i]=0;
  2172.   temp3[i]=0;
  2173. }
  2174. while(num--)
  2175.   for(j=0;j<n;j++)//滚动
  2176.   {
  2177.    for(k=7;k>=0;k--)//读取数据
  2178.     temp[7-k]=x[j*8+k];
  2179.    for(k=0;k<8;k++)//移动8位
  2180.    {
  2181.     for(i=0;i<8;i++)
  2182.     {
  2183.      temp0[i]=(temp0[i]<<1)|(temp1[i]>>7);
  2184.      temp1[i]=(temp1[i]<<1)|(temp2[i]>>7);
  2185.      temp2[i]=(temp2[i]<<1)|(temp3[i]>>7);
  2186.      temp3[i]=(temp3[i]<<1)|(temp[i]>>7);
  2187.      temp[i]<<=1;
  2188.      fun1(a+i*8,temp0[i],temp1[i],temp2[i],temp3[i]);
  2189.     }
  2190.     zhen(a,v);
  2191.    }
  2192.   }
  2193. }
  2194. void fun1(uchar *a,uchar d,uchar b,uchar c,uchar e)//滚动字幕数据处理
  2195. {
  2196. char i;
  2197. for(i=0;i<8;i++)
  2198. {
  2199.   a[i]=e&0x01;
  2200.   e>>=1;
  2201. }
  2202. a[7]|=(c<<1);
  2203. a[6]|=(c&0x80);
  2204. for(i=0;i<6;i++)
  2205. {
  2206.   a[5-i]|=((b<<(7-i))&0x80);
  2207. }
  2208. d=daoxu(d);
  2209. a[0]|=((d>>1)&0x7e);
  2210. }
  2211. uchar daoxu(uchar x)//一字节倒序
  2212. {
  2213. uchar k=0;
  2214. char i;
  2215. for(i=0;i<8;i++)
  2216. {
  2217.   if((x>>(7-i))&0x01)
  2218.    k|=0x01<<i;
  2219. }
  2220. return k;
  2221. }
  2222. void fn(char v)
  2223. {
  2224. uchar a[64]={0};
  2225. int i;
  2226. for(i=0;i<128;i++)//点
  2227. {
  2228.   a[tab00[i]]=(0x01<<tab01[i]);
  2229.   zhen(a,v);
  2230.   a[tab00[i]]=0;
  2231. }
  2232. for(i=0;i<128;i++)//8点
  2233. {
  2234.   a[tab10[i]]|=(0x01<<tab01[i]);
  2235.   if(i>=8)
  2236.    a[tab10[i-8]]^=(0x01<<tab01[i-8]);
  2237.   zhen(a,v);
  2238. }
  2239. a[tab00[0]]|=(0x01<<tab01[0]);
  2240. a[0]=0x80;
  2241. zhen(a,v);
  2242. for(i=1;i<128;i++)//线
  2243. {
  2244.   if(i<8)
  2245.    a[i-1]=0;
  2246.   a[tab00[i]]|=(0x01<<tab01[i]);
  2247.   zhen(a,v);
  2248. }
  2249. zhen(a,120);
  2250. for(i=0;i<128;i++)//线
  2251. {
  2252.   a[tab10[i]]^=(0x01<<tab01[i]);
  2253.   zhen(a,v);
  2254. }
  2255. }
  2256. void linkpc1(char v)
  2257. {
  2258. uchar i,a[64]={0};
  2259. for(i=0;i<7;i++)
  2260.   a[7*8+i]=0xff;
  2261. for(i=0;i<8;i++)
  2262. {
  2263.   move(a,2,0,1);
  2264.   zhen(a,v);
  2265. }
  2266. }
  2267. void pc1(char num,char v)
  2268. {
  2269. uchar a[64]={0};
  2270. char i,j;
  2271. while(num--)
  2272. {
  2273.   for(i=1;i<8;i++)
  2274.    a[i]=0xff;
  2275.   zhen(a,v);
  2276.   for(i=1;i<8;i++)
  2277.   {
  2278.    move(a,2,1,1);
  2279.    for(j=0;j<8;j++)
  2280.     a[j]=0xff;
  2281.    zhen(a,v);
  2282.   }
  2283.   for(i=0;i<8;i++)
  2284.   {
  2285.    if(num==0&&i==7)
  2286.     continue;
  2287.    move(a,2,1,1);
  2288.    zhen(a,v);
  2289.   }
  2290. }
  2291. for(i=0;i<7;i++)
  2292. {
  2293.   move(a,2,0,1);
  2294.   zhen(a,v+5);
  2295. }
  2296. }
  2297. void denghuo(char v)
  2298. {
  2299. uchar a[64];
  2300. char i,j,k;
  2301. for(k=0;k<8;k++)
  2302.   for(i=0;i<8;i++)
  2303.    for(j=0;j<8;j++)
  2304.    {
  2305.     a[tab_mian[i]*8+tab_xian[j]]|=(0x01<<tab_dian[(i+j)*8+k]);
  2306.     zhen(a,v);
  2307.    }
  2308.   zhen(a,90);
  2309. for(k=0;k<8;k++)
  2310.   for(i=0;i<8;i++)
  2311.    for(j=0;j<8;j++)
  2312.    {
  2313.     a[tab_mian[i]*8+tab_xian[j]]^=(0x01<<tab_dian[(i+j)*8+k]);
  2314.     zhen(a,v);
  2315.    }
  2316. }
  2317. void link_pingmian1(char v)
  2318. {
  2319. uchar a[64]={0};
  2320. char i,j;
  2321. for(i=0;i<8;i++)
  2322.   for(j=0;j<8;j++)
  2323.   {
  2324.    a[7*8+j]|=(0x01<<i);
  2325.    zhen(a,v);
  2326.   }
  2327. }
  2328. void pingmian1(char num,char v)
  2329. {
  2330. char i,k;
  2331. uchar a[64]={0};
  2332. for(i=0;i<8;i++)
  2333.   a[7*8+i]=0xff;
  2334. zhen(a,v);
  2335. while(num--)
  2336.   for(i=0;i<28;i++)
  2337.   {
  2338.    if(i<7)
  2339.     for(k=0;k<8;k++)
  2340.     {
  2341.      a[(6-i)*8+k]=0x01;
  2342.      a[7*8+k]>>=1;
  2343.     }
  2344.    else if(i<14)
  2345.     for(k=0;k<8;k++)
  2346.     {
  2347.      a[k]|=0x01<<(i-6);
  2348.      a[(14-i)*8+k]=0;
  2349.     }
  2350.    else if(i<21)
  2351.     for(k=0;k<8;k++)
  2352.     {
  2353.      a[(i-13)*8+k]=0x80;
  2354.      a[k]<<=1;
  2355.     }
  2356.    else
  2357.     for(k=0;k<8;k++)
  2358.     {
  2359.      a[7*8+k]|=0x80>>(i-20);
  2360.      a[(i-21)*8+k]=0;
  2361.     }
  2362.    zhen(a,v);
  2363.   }
  2364. CLEAR();
  2365. }
  2366. void print(uchar *a,char m)//m=0中空显示,m=1实心显示
  2367. {
  2368. uchar p;
  2369. char i,j,k;
  2370. uchar b[64]={0};
  2371. for(i=0;i<8;i++)
  2372. {
  2373.   b[7*8+i]=0xff;
  2374. }
  2375. for(i=0;i<8;i++)//行切换
  2376. {
  2377.   for(j=0;j<8;j++)//点移动
  2378.   {
  2379.    p=a[i]&(0x01<<j);
  2380.    if(p)
  2381.    {
  2382.     for(k=6;k>0;k--)
  2383.     {
  2384.      if(m==1&&k==6)
  2385.      {;}
  2386.      else
  2387.       b[(k+1)*8+7-i]&=(~p);
  2388.      b[k*8+7-i]|=(0x01<<j);
  2389.      zhen(b,1);
  2390.     }
  2391.     b[1*8+7-i]=0;
  2392.     b[7-i]|=p;
  2393.     zhen(b,1);
  2394.    }
  2395.    b[7-i]|=p;
  2396.   }
  2397. }
  2398. zhen(b,40);
  2399. b[0]=0;
  2400. for(j=7;j>0;j--)
  2401. {
  2402.   for(i=7;i>0;i--)
  2403.   {
  2404.    b[i]=b[i-1];

  2406.   }
  2407.    zhen(b,5);  
  2408. }
  2409.   CLEAR();
  2410. }
  2411. void link_jb0(char v)
  2412. {
  2413. uchar a[64]={0};
  2414. char i;
  2415. for(i=0;i<64;i++)
  2416. {
  2417.   a[i]=0x80;
  2418.   zhen(a,v);
  2419. }
  2420. }
  2421. void jb0(char num,char v)///////////////////////////////
  2422. {
  2423. char i,k;
  2424. uchar c[64]={0};
  2425. for(i=0;i<64;i++)
  2426.   c[i]=0x80;
  2427. zhen(c,v);
  2428. while(num--)
  2429.   for(i=0;i<28;i++)
  2430.   {
  2431.    if(i<7)
  2432.     for(k=0;k<8;k++)
  2433.     {
  2434.      c[k*8]|=(0x80>>(i+1));
  2435.      c[k*8+7-i]=0;
  2436.     }
  2437.    else if(i<14)
  2438.     for(k=0;k<8;k++)
  2439.     {
  2440.      c[k*8+i-6]=0x01;
  2441.      c[k*8]>>=0x01;
  2442.     }
  2443.    else if(i<21)
  2444.     for(k=0;k<8;k++)
  2445.     {
  2446.      c[k*8+i-14]=0;
  2447.      c[k*8+7]|=(0x01<<(i-13));
  2448.     }
  2449.    else if(i<28)
  2450.     for(k=0;k<8;k++)
  2451.     {
  2452.      c[k*8+27-i]=0x80;
  2453.      c[k*8+7]<<=1;
  2454.     }
  2455.    zhen(c,v);
  2456.   }
  2457.         CLEAR();
  2458. }
  2459. /****************************
  2460. 旋转衔接
  2461. ******************************/
  2462. void link(char v)
  2463. {

  2465. char i,j,k;
  2466. uchar a[64]={0};
  2467. for(i=0;i<64;i++)
  2468.   a[i]=0x80;
  2469. zhen(a,3);
  2470. for(i=0;i<8;i++)
  2471. {
  2472.   for(j=0;j<8;j++)
  2473.   {
  2474.    if(i<7)
  2475.     a[j*8+7-i]&=0x7f;
  2476.    a[j*8+i]|=(0x80>>i);
  2477.   }
  2478.   zhen(a,v);
  2479. }
  2480. for(i=0;i<6;i++)
  2481. {
  2482.   for(j=0;j<8;j++)
  2483.    for(k=0;k<8;k++)
  2484.     a[j*8+k]=tab_xuanzhuantiao[(i+8)*8+k];
  2485.   zhen(a,3);
  2486. }
  2487. }
  2488. void xuanzhuantiao2(char num,char v)//空心旋转,kind=1实心,否则空心
  2489. {
  2490. uchar a[64]={0};
  2491. char i,j,k;
  2492. while(num--)
  2493.   for(i=0;i<56;i++)
  2494.   {
  2495.    for(j=0;j<8;j++)
  2496.     for(k=0;k<8;k++)
  2497.      a[j*8+k]=tab_xuanzhuantiao2[i*8+k];
  2498.    zhen(a,v);
  2499.   }
  2500. }
  2501. void xzcube()
  2502. {
  2503.   char i;
  2504.   donghua(y_table,6,8,8);
  2505.   for(i=0;i<26;i++)
  2506.   {
  2507.    if(i==12||i==13||i==14)
  2508.     zhen(yx_table+i*64,30);
  2509.    else
  2510.     zhen(yx_table+i*64,14);
  2511.   }
  2512.   donghua(x_table,6,8,8);
  2513.   for(i=0;i<26;i++)
  2514.   {
  2515.    if(i==12||i==13||i==14)
  2516.     zhen(xz_table+i*64,30);
  2517.    else
  2518.     zhen(xz_table+i*64,14);
  2519.   }
  2520.   donghua(z_table,6,8,8);
  2521. }

  2523. void shensuo(uchar v)
  2524. {
  2525. char i,j;
  2526. uchar a[64]={0};
  2527. for(i=0;i<64;i++)
  2528.   a[i]=0xff;
  2529. for(i=0;i<7;i++)
  2530. {
  2531.   move(a,0,0,1);
  2532.   zhen(a,v);
  2533. }
  2534. for(i=0;i<7;i++)
  2535. {
  2536.   move(a,0,1,1);
  2537.   for(j=0;j<64;j++)
  2538.    a[j]|=0x01;
  2539.   zhen(a,v);
  2540. }
  2541. for(i=0;i<7;i++)
  2542. {
  2543.   move(a,2,0,1);
  2544.   zhen(a,v);
  2545. }
  2546. for(i=0;i<7;i++)
  2547. {
  2548.   move(a,2,1,1);
  2549.   for(j=0;j<8;j++)
  2550.    a[j]|=0xff;
  2551.   zhen(a,v);
  2552. }
  2553. for(i=7;i>0;i--)
  2554. {
  2555.   for(j=0;j<8;j++)
  2556.    a[j*8+i]=0;
  2557.   zhen(a,v);
  2558. }
  2559. for(i=1;i<8;i++)
  2560. {
  2561.   for(j=0;j<8;j++)
  2562.    a[j*8+i]|=0xff;
  2563.   zhen(a,v);
  2564. }
  2565. }
  2566. void cube(char empty,char kind,char v)
  2567. {
  2568. uchar a[64]={0};
  2569. char i;
  2570. for(i=1;i<=8;i++)//生成
  2571. {
  2572.   if(empty==0)
  2573.    produce_cube(a,i);
  2574.   else
  2575.    produce_empty(a,i);
  2576.   if(kind==0)
  2577.    {;}
  2578.   else if(kind==1)
  2579.    move(a,1,1,8-i);
  2580.   else if(kind==2)
  2581.   {
  2582.    move(a,1,1,8-i);
  2583.    move(a,0,1,8-i);
  2584.   }
  2585.   else
  2586.    move(a,0,1,8-i);
  2587.   zhen_1(a,v);
  2588.   //Delayms(200);

  2590. }

  2592. for(i=7;i>0;i--)//退出
  2593. {
  2594.   if(empty==0)
  2595.    produce_cube(a,i);
  2596.   else
  2597.    produce_empty(a,i);
  2598.   if(kind==0)
  2599.   {
  2600.    move(a,1,1,8-i);
  2601.    move(a,0,1,8-i);
  2602.   }
  2603.   else if(kind==1)
  2604.    move(a,0,1,8-i);
  2605.   else if(kind==2)
  2606.    {;}
  2607.   else
  2608.    move(a,1,1,8-i);  
  2609.   zhen_1(a,v);
  2610.    //Delayms(200);
  2611.   
  2612. }
  2613. }
  2614. void produce_empty(uchar *a,char n)//0<n<=8,注意n不能为0
  2615. {
  2616. char j;
  2617. uchar p;
  2618. for(j=0;j<64;j++)
  2619.   a[j]=0;
  2620. p=0xff>>(8-n);
  2621. /************X4列*************/
  2622. a[(n-1)*8+n-1]=p;
  2623. a[(n-1)*8]=p;
  2624. a[0]=p;
  2625. a[n-1]=p;
  2626. for(j=0;j<n;j++)
  2627. {
  2628.   p=(0x01|(0x01<<(n-1)));
  2629. /************竖直4列*************/
  2630.   a[j*8]|=p;
  2631.   a[j*8+n-1]|=p;
  2632. /************Y4列*************/
  2633.   a[j]|=p;
  2634.   a[(n-1)*8+j]|=p;
  2635. }
  2636. }
  2637. void shandian(char v)
  2638. {
  2639.   char i,j;
  2640.   uchar a[64];
  2641.   for(i=0;i<64;i++)
  2642.    a[i]=tab_shandian[64*21+i];
  2643.   for(i=0;i<22;i++)
  2644.    zhen(tab_shandian+64*i,v);
  2645.   for(i=0;i<22;i++)
  2646.   {
  2647.    for(j=0;j<64;j++)
  2648.     a[j]=a[j]&(~tab_shandian[64*i+j]);
  2649.    zhen(a,v);
  2650.    Delayms(10);
  2651.   }
  2652. }
  2653. void szfc0(char v)//数字上浮
  2654. {
  2655. char i,j;
  2656. uchar a[64];
  2657. for(i=0;i<64;i++)
  2658. {
  2659.   a[i]=0;
  2660. }
  2661. for(j=124;j>=0;j--)
  2662. {
  2663.   for(i=7;i>=0;i--)
  2664.   {
  2665.    a[i*8+3]=szfc_table[j+i];
  2666.    a[i*8+4]=szfc_table[j+i];
  2667.   }
  2668.   zhen(a,v);
  2669. }
  2670. }
  2671. void rain(char menu,char num,char v)
  2672. {//menu=0,up;menu=1,down
  2673. uchar a[64]={0};
  2674. char i,j;
  2675. if(menu==0)
  2676. {
  2677.   for(i=0;i<8;i++)
  2678.    a[i]=tab_rain[i];
  2679.   zhen(a,v);
  2680.   for(i=1;i<8;i++)
  2681.   {
  2682.    move(a,2,1,1);
  2683.    for(j=0;j<8;j++)
  2684.     a[j]=tab_rain[i*8+j];
  2685.    zhen(a,v);
  2686.   }
  2687.   while(num--)
  2688.   {
  2689.    for(i=0;i<8;i++)
  2690.    {
  2691.     move(a,2,1,1);
  2692.     for(j=0;j<8;j++)
  2693.      a[j]=tab_rain[i*8+j];
  2694.     zhen(a,v);
  2695.    }
  2696.   }
  2697. }
  2698. else
  2699. {
  2700.   for(i=0;i<8;i++)
  2701.    a[7*8+i]=tab_rain[i];
  2702.   zhen(a,v);
  2703.   for(i=1;i<8;i++)
  2704.   {
  2705.    move(a,2,0,1);
  2706.    for(j=0;j<8;j++)
  2707.     a[7*8+j]=tab_rain[i*8+j];
  2708.    zhen(a,v);
  2709.   }
  2710.   while(num--)
  2711.   {
  2712.    for(i=0;i<8;i++)
  2713.    {
  2714.     move(a,2,0,1);
  2715.     for(j=0;j<8;j++)
  2716.      a[j+7*8]=tab_rain[i*8+j];
  2717.     zhen(a,v);
  2718.    }   
  2719.   }
  2720. }
  2721. }
复制代码
作者: xiaoou    时间: 2015-3-19 14:59
哇这个太酷了，楼主的动手能力真强，而且程序的思路很清晰，值得收藏。
作者: wang215322    时间: 2015-4-7 20:24
真是太厉害了，51hei有你更精彩！！
作者: x327028539    时间: 2015-4-28 23:05
楼主，分享一下原理图吧
作者: my_way_old    时间: 2015-5-2 21:24
x327028539 发表于 2015-4-28 23:05
楼主，分享一下原理图吧

硬件这块你可以上网上搜一下，很多的 ，也很详细
我就是IO的选择很被人不同而已   我的这个选择不是最优的
网上有些大神的IO分配很合理，画PCB时更容易
我更新了   你自己下载下
注： 我的2083是后加的小模块，没在原理图里的，你自己在去整合下，你将就的参考下
作者: bjk3388    时间: 2015-5-3 18:56
学习学习。。。。。。。。。。。。。。。。。
作者: 只要    时间: 2015-5-3 22:22
程序稍不过去。为什么
作者: 将青衫隐去    时间: 2015-5-11 18:32
学习！
作者: 将青衫隐去    时间: 2015-5-11 18:34
很好的资料，学习
作者: 香蕉1373    时间: 2015-5-19 00:22
买个套件学习下
作者: 牵只羊    时间: 2015-5-28 14:31
真的很厉害
作者: wgw020    时间: 2015-6-11 19:28
哇这个太酷了，楼主的动手能力真强，而且程序的思路很清晰，值得收藏。
作者: 三米世界    时间: 2015-9-15 13:56
谢楼主分享。。。。果断拿走啊谢楼主分享。。。。果断拿走啊
作者: L-QQ    时间: 2015-9-16 21:29
楼主太强大了
作者: fslgh123    时间: 2015-9-22 11:35
好强大啊。LED也是自己焊接的吗？
作者: 蒲公英hi    时间: 2015-9-22 17:45
很棒，讨好了
作者: ludaijin    时间: 2015-10-6 20:35
很棒，讨好了
作者: ZW1996    时间: 2015-11-20 16:01
编译不能通过怎么回事啊
作者: ZW1996    时间: 2015-11-20 16:05
只要 发表于 2015-5-3 22:22
**** 作者被禁止或删除 内容自动屏蔽 ****

大神，问一下，你的程序现在能烧过去了吗，我也遇到这个问题了
作者: 这是小号    时间: 2015-12-1 11:22
膜拜膜拜
作者: yangkai3bu    时间: 2015-12-4 16:24
大神牛逼，这算法得多烧脑啊。
作者: 14781708282    时间: 2016-1-14 11:18
译不能通过怎么回事啊
作者: my_way_old    时间: 2016-1-18 23:25
14781708282 发表于 2016-1-14 11:18
译不能通过怎么回事啊

你好，有可能我用的烧录软件和你的不一样等等因素，所以译不过去。我的建议是你用你自己写好的，然后又经常用、烧录没问题的头文件和宏定义等等，然后再截取我里面对你有用的部分不断的填充你自己的程序中去，改程序，把它变成你自己的东西。这样也就不会出现烧录和其他问题了
作者: lanchonglan    时间: 2016-1-19 18:59
太棒了，真的好好学学了。
作者: doi    时间: 2016-5-15 22:08
楼主很棒，学习了
作者: hanzq    时间: 2016-5-16 00:06
51hei有你更精彩！！
作者: wqxstar    时间: 2016-11-17 15:24
为什么调不通呢，下载个代码看看
作者: 13666255644    时间: 2016-12-29 13:34
正方形就好了
作者: 哇擦嘞    时间: 2017-1-31 19:03
好厉害
作者: mengxingshifen    时间: 2017-2-1 00:03
给力给力！
作者: 有你13真好    时间: 2017-5-31 18:33
我要下载
作者: 距离感    时间: 2017-7-18 16:38
这光立方的LED动画效果太炫了！多谢楼主的程序！
作者: 电子FSY    时间: 2017-10-20 17:04
非常好，谢谢分享
作者: hjx620    时间: 2017-11-1 11:31
非常好，谢谢分享
作者: qqqq5    时间: 2018-1-31 18:37

51hei有你更精彩！！
作者: qqqq5    时间: 2018-1-31 18:37

51hei有你更精彩！！
作者: my_way_old    时间: 2019-11-8 01:00
当时的光立方视频：v.youku.com/v_show/id_XOTEyNzI0MDU2.html，现在看几年前做的东西，感觉好好笑，哈哈哈哈~
作者: abcd123321123    时间: 2022-6-16 19:52
这是8 X8 x8吗



欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1