595+2803光立方整套资料（原理图+PCB+程序）

595+2803光立方整套资料（原理图+PCB+程序） 分享给大家

为了避免过孔过多(由于595级联),在595的11，12,13脚加了排阵，但是焊的时候请飞线，但是有顺序的，具体想看原理图，不要乱飞，U1,5,8,10，是在一起的，但是最好看下原理图，以免我看错了哈，然后U2,4,7,11，在一起，不要看错了哈，然后人都有错误的哈，如果我的原理图和原来的原理图对不上，只能说我是傻子了，在这里给大家道歉了。


在图中加了三个按键，是为以后开发其他功能所用，流出来的排阵，P1口是留给键盘的，以后玩贪吃蛇，不知道我能做出来不，还有做时钟什么的，但这是木易大叔的主意哈。


我也是菜鸟，只想把我会的告诉大家，如果觉得我哪里不足可以提意见，我知道我的PCB布线有很大问题，但是我很努力的在学习，希望大家能够喜欢，不喜欢也不要喷偶，偶心理承受能力比较弱，私下提建议哈，谢谢你了。


打印的时候记得顶层要镜像，然后是，很多都是贴片元件哦，不过为了方便大家，我把引脚拉长了，焊的时候先用焊锡走一遍，避免到时候虚焊了


  光立方原理图


  光立方的所有资料打包下载：
光立方（595 2803）.zip (1.12 MB, 下载次数: 271)

2016-5-15 22:23 上传

点击文件名下载附件
595+2803


源码预览如下：

1. /*Ideasoft
   
2. 
   
3. Display memery:display[8][8];
   
4. */
   
5. #include "reg52.h"
   
6. #include<intrins.h>
   
7. 
   
8. #define uchar unsigned char
   
9. #define uint unsigned int
   
10. 
    
11. sbit STCP = P3^2;
    
12. uchar display[8][8];
    
13. /*rank:A,1,2,3,4,I,心,U*/
    
14. uchar code table_cha[8][8]={0x51,0x51,0x51,0x4a,0x4a,0x4a,0x44,0x44,0x18,0x1c,0x18,0x18,0x18,0x18,0x18,0x3c,0x3c,0x66,0x66,0x30,0x18,0xc,0x6,0xf6,0x3c,0x66,0x60,0x38,0x60,0x60,0x66,0x3c,0x30,0x38,0x3c,0x3e,0x36,0x7e,0x30,0x30,0x3c,0x3c,0x18,0x18,0x18,0x18,0x3c,0x3c,0x66,0xff,0xff,0xff,0x7e,0x3c,0x18,0x18,0x66,0x66,0x66,0x66,0x66,0x66,0x7e,0x3c};
    
15. /*the "ideasoft"*/
    
16. uchar code table_id[40]={0x81,0xff,0x81,0x00,0xff,0x81,0x81,0x7e,0x00,0xff,0x89,0x89,0x00,0xf8,0x27,0x27,0xf8,0x00,0x8f,0x89,0x89,0xf9,0x00,0xff,0x81,0x81,0xff,0x00,0xff,0x09,0x09,0x09,0x01,0x0,0x01,0x01,0xff,0x01,0x01,0x00};
    
17. /*railway*/
    
18. uchar code dat[128]={0x0,0x20,0x40,0x60,0x80,0xa0,0xc0,0xe0,0xe4,0xe8,0xec,0xf0,0xf4,0xf8,0xfc,0xdc,0xbc,0x9c,0x7c,0x5c,0x3c,0x1c,0x18,0x14,0x10,0xc,0x8,0x4,0x25,0x45,0x65,0x85,0xa5,0xc5,0xc9,0xcd,0xd1,0xd5,0xd9,0xb9,0x99,0x79,0x59,0x39,0x35,0x31,0x2d,0x29,0x4a,0x6a,0x8a,0xaa,0xae,0xb2,0xb6,0x96,0x76,0x56,0x52,0x4e,0x6f,0x8f,0x93,0x73,0x6f,0x8f,0x93,0x73,0x4a,0x6a,0x8a,0xaa,0xae,0xb2,0xb6,0x96,0x76,0x56,0x52,0x4e,0x25,0x45,0x65,0x85,0xa5,0xc5,0xc9,0xcd,0xd1,0xd5,0xd9,0xb9,0x99,0x79,0x59,0x39,0x35,0x31,0x2d,0x29,0x0,0x20,0x40,0x60,0x80,0xa0,0xc0,0xe0,0xe4,0xe8,0xec,0xf0,0xf4,0xf8,0xfc,0xdc,0xbc,0x9c,0x7c,0x5c,0x3c,0x1c,0x18,0x14,0x10,0xc,0x8,0x4};
    
19. /*railway 2*/
    
20. uchar code dat2[28]={0x0,0x20,0x40,0x60,0x80,0xa0,0xc0,0xe0,0xe4,0xe8,0xec,0xf0,0xf4,0xf8,0xfc,0xdc,0xbc,0x9c,0x7c,0x5c,0x3c,0x1c,0x18,0x14,0x10,0xc,0x8,0x4};
    
21. /*railway 3*/
    
22. uchar code dat3[24]={0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x16,0x26,0x36,0x46,0x56,0x66,0x65,0x64,0x63,0x62,0x61,0x60,0x50,0x40,0x30,0x20,0x10};
    
23. /*3p char*/
    
24. uchar code table_3p[3][8]={0xff,0x89,0xf5,0x93,0x93,0xf5,0x89,0xff,0x0e,0x1f,0x3f,0x7e,0x7e,0x3f,0x1f,0x0e,0x18,0x3c,0x7e,0xff,0x18,0x18,0x18,0x18};
    
25. /*initializtion
    
26. That is to initialize the program .
    
27. It is write to set the timer in c52 mcu.
    
28. So the program can renovate the led_3d_cube in fixed time use the interrupt function.*/
    
29. 
    
30. void sinter(void)
    
31. {
    
32.     IE=0x82;
    
33.         TCON=0x01;
    
34.         TH0=0xc0;
    
35.         TL0=0;
    
36.         TR0=1;
    
37.          
    
38.         TMOD = 0x20;
    
39.     PCON = 0x00;
    
40.     SCON = 0x00;                                               
    
41. }
    
42. void delay(uint i)
    
43. {                                                                                       
    
44.         uchar b;
    
45.         while (i--)
    
46.         {
    
47.                 b=3;
    
48.                 while(b--);
    
49.         }
    
50.         ;
    
51. }
    
52. /*判断一个数值的第n位，是1还是0，并返回相应数值*/
    
53. uchar judgebit(uchar num,uchar b)
    
54. {
    
55.         char n;
    
56.         num=num&(1<<b);
    
57.         if (num)
    
58.         n=1;
    
59.         else
    
60.         n=0;
    
61.         return n;
    
62. }
    
63. /*To figure out the round number*/
    
64. uchar abs(uchar a)
    
65. {
    
66.         uchar b;
    
67.         b=a/10;
    
68.         a=a-b*10;
    
69.         if (a>=5)
    
70.         b++;
    
71.         return b;
    
72. }
    
73. /*To figure out the absolute value*/
    
74. uchar abss(char a)
    
75. {
    
76.         if (a<0)
    
77.         a=-a;
    
78.         return a;
    
79. }
    
80. /*The function can comparat the character.
    
81. And remove the big one to the back.*/
    
82. void max(uchar *a,uchar *b)
    
83. {
    
84.    uchar t;
    
85.    if ((*a)>(*b))
    
86.    {
    
87.                 t=(*a);
    
88.                 (*a)=(*b);
    
89.                 (*b)=t;   
    
90.    }
    
91. }
    
92. /*The function is to figure out the max number and return it.*/
    
93. uchar maxt(uchar a,uchar b,uchar c)
    
94. {
    
95.         if (a<b)
    
96.         a=b;
    
97.         if (a<c)
    
98.         a=c;
    
99.         return a;
    
100. }
     
101. void clear(char le)
     
102. {
     
103.         uchar i,j;
     
104.         for (j=0;j<8;j++)
     
105.         {
     
106.                 for (i=0;i<8;i++)
     
107.                 display[j][i]=le;
     
108.         }
     
109. }
     
110. void trailler(uint speed)
     
111. {
     
112.         char i,j;
     
113.         for (i=6;i>=-3;i--)
     
114.         {
     
115.                 if (i>=0)
     
116.                 {
     
117.                         for (j=0;j<8;j++)
     
118.                         display[j][i]=display[j][i+1];
     
119.                 }
     
120.                 if (i<4)
     
121.                 {
     
122.                         for (j=0;j<8;j++)
     
123.                         display[j][i+4]=0;
     
124.                 }
     
125.                 delay(speed);
     
126.         }
     
127. }
     
128. void point(uchar x,uchar y,uchar z,uchar le)
     
129. {
     
130.         uchar ch1,ch0;
     
131.         ch1=1<<x;
     
132.         ch0=~ch1;
     
133.         if (le)
     
134.         display[z][y]=display[z][y]|ch1;
     
135.         else
     
136.         display[z][y]=display[z][y]&ch0;
     
137. }
     
138. void type(uchar cha,uchar y)
     
139. {       
     
140.         uchar xx;
     
141.         for (xx=0;xx<8;xx++)
     
142.         {
     
143.         display[xx][y]=table_cha[cha][xx];
     
144.         }
     
145. }
     
146. /*The first variable is the distance from the midpoint.
     
147. The second is the layer.
     
148. the third is the flash speed of the time between each two point.
     
149. The forth is the enable io,it controls weather draw or claen.*/
     
150. void cirp(char cpp,uchar dir,uchar le)
     
151. {
     
152.         uchar a,b,c,cp;
     
153.         if ((cpp<128)&(cpp>=0))
     
154.         {
     
155.                 if (dir)
     
156.                 cp=127-cpp;
     
157.                 else
     
158.                 cp=cpp;
     
159.                 a=(dat[cp]>>5)&0x07;
     
160.                 b=(dat[cp]>>2)&0x07;
     
161.                 c=dat[cp]&0x03;
     
162.                 if (cpp>63)
     
163.                 c=7-c;
     
164.                 point (a,b,c,le);
     
165.         }
     
166. }
     
167. void line(uchar x1,uchar y1,uchar z1,uchar x2,uchar y2,uchar z2,uchar le)
     
168. {
     
169.         char t,a,b,c,a1,b1,c1,i;
     
170.         a1=x2-x1;
     
171.         b1=y2-y1;
     
172.         c1=z2-z1;
     
173.         t=maxt(abss(a1),abss(b1),abss(c1));
     
174.         a=x1*10;
     
175.         b=y1*10;
     
176.         c=z1*10;
     
177.         a1=a1*10/t;
     
178.         b1=b1*10/t;
     
179.         c1=c1*10/t;
     
180.         for (i=0;i<t;i++)
     
181.         {
     
182.                 point(abs(a),abs(b),abs(c),le);
     
183.                 a+=a1;
     
184.                 b+=b1;
     
185.                 c+=c1;
     
186.         }
     
187.         point(x2,y2,z2,le);
     
188. }
     
189. void box(unsigned char x1,unsigned char z1,unsigned char y1,unsigned char x2,unsigned char z2,unsigned char y2,unsigned char fill,unsigned char le)
     
190. {
     
191.         uchar i,j,t=0;
     
192.         max(&x1,&x2);
     
193.         max(&y1,&y2);
     
194.         max(&z1,&z2);
     
195.         for (i=x1;i<=x2;i++)
     
196.                 t|=1<<i;
     
197.         if (!le)
     
198.                 t=~t;
     
199.         if (fill)
     
200.         {
     
201.                 if (le)
     
202.                 {
     
203.                         for (i=z1;i<=z2;i++)
     
204.                         {
     
205.                                 for (j=y1;j<=y2;j++)
     
206.                                         display[j][i]|=t;
     
207.                         }
     
208.                 }
     
209.                 else
     
210.                 {
     
211.                         for (i=z1;i<=z2;i++)
     
212.                         {
     
213.                                 for (j=y1;j<=y2;j++)
     
214.                                         display[j][i]&=t;
     
215.                         }
     
216.                 }
     
217.         }
     
218.         else
     
219.         {
     
220.                 if (le)
     
221.                 {
     
222.                         display[y1][z1]|=t;
     
223.                         display[y2][z1]|=t;
     
224.                         display[y1][z2]|=t;
     
225.                         display[y2][z2]|=t;
     
226.                 }
     
227.                 else
     
228.                 {
     
229.                          display[y1][z1]&=t;
     
230.                         display[y2][z1]&=t;
     
231.                         display[y1][z2]&=t;
     
232.                         display[y2][z2]&=t;
     
233.                 }
     
234.                 t=(0x01<<x1)|(0x01<<x2);
     
235.                 if (!le)
     
236.                         t=~t;
     
237.                 if (le)
     
238.                 {
     
239.                         for (j=z1;j<=z2;j+=(z2-z1))
     
240.                         {
     
241.                                 for (i=y1;i<=y2;i++)
     
242.                                         display[i][j]|=t;
     
243.                         }
     
244.                         for (j=y1;j<=y2;j+=(y2-y1))
     
245.                         {
     
246.                                 for (i=z1;i<=z2;i++)
     
247.                                         display[j][i]|=t;
     
248.                         }
     
249.                 }
     
250.                 else
     
251.                 {
     
252.                         for (j=z1;j<=z2;j+=(z2-z1))
     
253.                         {
     
254.                                 for (i=y1;i<=y2;i++)
     
255.                                 {
     
256.                                 display[i][j]&=t;
     
257.                                 }
     
258.                         }
     
259.                         for (j=y1;j<=y2;j+=(y2-y1))
     
260.                         {
     
261.                                 for (i=z1;i<=z2;i++)
     
262.                                 {
     
263.                                 display[j][i]&=t;
     
264.                                 }
     
265.                         }
     
266.                 }
     
267.         }
     
268. }
     
269. void box_apeak_xy(uchar x1,uchar y1,uchar z1,uchar x2,uchar y2,uchar z2,uchar fill,uchar le)
     
270. {
     
271.         uchar i;
     
272.         max(&z1,&z2);
     
273.         if (fill)
     
274.         {
     
275.                 for (i=z1;i<=z2;i++)
     
276.                 {
     
277.                         line (x1,y1,i,x2,y2,i,le);
     
278.                 }
     
279.         }
     
280.         else
     
281.         {
     
282.                 line (x1,y1,z1,x2,y2,z1,le);
     
283.                 line (x1,y1,z2,x2,y2,z2,le);
     
284.                 line (x2,y2,z1,x2,y2,z2,le);
     
285.                 line (x1,y1,z1,x1,y1,z2,le);
     
286.         }
     
287. }
     
288. void box_parallel_xy(uchar x1,uchar y1,uchar z1,uchar x2,uchar y2,uchar z2,uchar le)
     
289. {
     
290.         uchar i;
     
291.         max(&y1,&y2);
     
292.         for (i=y1;i<=y2;i++)
     
293.         {
     
294.                 line (x1,i,z1,x2,i,z2,le);
     
295.         }
     
296. }
     
297. void poke(uchar n,uchar x,uchar y)
     
298. {
     
299.         uchar i;
     
300.         for (i=0;i<8;i++)
     
301.         {
     
302.          point(x,y,i,judgebit(n,i));
     
303.         }
     
304. }
     
305. void boxtola(char i,uchar n)
     
306. {
     
307.         if ((i>=0)&(i<8))
     
308.         {
     
309.                 poke(n,0,7-i);
     
310.         }
     
311.         if ((i>=8)&(i<16))
     
312.         {
     
313.                 poke(n,i-8,0);
     
314.         }
     
315.         if ((i>=16)&(i<24))
     
316.         {
     
317.                 poke(n,7,i-16);
     
318.         }
     
319. 
     
320. }
     
321. void rolldisplay(uint speed)
     
322. {
     
323.         uchar j;
     
324.         char i,a;
     
325.         for (i=23;i>-40;i--)
     
326.         {
     
327.                 for (j=0;j<40;j++)
     
328.                 {
     
329.                         a=i+j;
     
330.                         if ((a>=0)&(a<24))
     
331.                         boxtola(a,table_id[j]);
     
332.                 }
     
333.                 delay(speed);
     
334.         }
     
335. }
     
336. void roll_apeak_yz(uchar n,uint speed)
     
337. {
     
338.         uchar i;
     
339.         switch(n)
     
340.         {
     
341.                 case 1:
     
342.                         for (i=0;i<7;i++)
     
343.                         {
     
344.                                 display[i][7]=0;
     
345.                                 display[7][6-i]=255;
     
346.                                 delay(speed);
     
347.                         };
     
348.                         break;
     
349.                 case 2:
     
350.                         for (i=0;i<7;i++)
     
351.                         {
     
352.                                 display[7][7-i]=0;
     
353.                                 display[6-i][0]=255;
     
354.                                 delay(speed);
     
355.                         };
     
356.                         break;
     
357.                 case 3:
     
358.                         for (i=0;i<7;i++)
     
359.                         {
     
360.                                 display[7-i][0]=0;
     
361.                                 display[0][i+1]=255;
     
362.                                 delay(speed);
     
363.                         };
     
364.                         break;
     
365.                 case 0:
     
366.                         for (i=0;i<7;i++)
     
367.                         {
     
368.                                 display[0][i]=0;
     
369.                                 display[i+1][7]=255;
     
370.                                 delay(speed);
     
371.                         };
     
372.         }
     
373. }
     
374. void roll_apeak_xy(uchar n,uint speed)
     
375. {
     
376.         uchar i;
     
377.         switch(n)
     
378.         {
     
379.                 case 1:
     
380.                         for (i=0;i<7;i++)
     
381.                         {
     
382.                                 line(0,i,0,0,i,7,0);
     
383.                                 line(i+1,7,0,i+1,7,7,1);
     
384.                                 delay(speed);
     
385.                         };
     
386.                         break;
     
387.                 case 2:
     
388.                         for (i=0;i<7;i++)
     
389.                         {
     
390.                                 line(i,7,0,i,7,7,0);
     
391.                                 line(7,6-i,0,7,6-i,7,1);
     
392.                                 delay(speed);
     
393.                         };
     
394.                         break;
     
395.                 case 3:
     
396.                         for (i=0;i<7;i++)
     
397.                         {
     
398.                                 line(7,7-i,0,7,7-i,7,0);
     
399.                                 line(6-i,0,0,6-i,0,7,1);
     
400.                                 delay(speed);
     
401.                         };
     
402.                         break;
     
403.                 case 0:
     
404.                         for (i=0;i<7;i++)
     
405.                         {
     
406.                                 line(7-i,0,0,7-i,0,7,0);
     
407.                                 line(0,i+1,0,0,i+1,7,1);
     
408.                                 delay(speed);
     
409.                         };
     
410.         }
     
411. }
     
412. void roll_3_xy(uchar n,uint speed)
     
413. {
     
414.         uchar i;
     
415.         switch(n)
     
416.         {
     
417.                 case 1:
     
418.                         for (i=0;i<8;i++)
     
419.                         {
     
420.                                 box_apeak_xy (0,i,0,7,7-i,7,1,1);
     
421.                                 delay(speed);
     
422.                                 if (i<7)
     
423.                                 box_apeak_xy (3,3,0,0,i,7,1,0);
     
424.                         };
     
425.                         break;
     
426.                 case 2:
     
427.                         for (i=0;i<8;i++)
     
428.                         {
     
429.                                 box_apeak_xy (7-i,0,0,i,7,7,1,1);
     
430.                                 delay(speed);
     
431.                                 if (i<7)
     
432.                                 box_apeak_xy (3,4,0,i,7,7,1,0);
     
433.                         };
     
434.                         break;
     
435.                 case 3:
     
436.                         for (i=0;i<8;i++)
     
437.                         {
     
438.                                 box_apeak_xy (0,i,0,7,7-i,7,1,1);
     
439.                                 delay(speed);
     
440.                                 if (i<7)
     
441.                                 box_apeak_xy (4,4,0,7,7-i,7,1,0);
     
442.                         };
     
443.                         break;
     
444.                 case 0:
     
445.                         for (i=0;i<8;i++)
     
446.                         {
     
447.                                 box_apeak_xy (7-i,0,0,i,7,7,1,1);
     
448.                                 delay(speed);
     
449.                                 if (i<7)
     
450.                                 box_apeak_xy (4,3,0,7-i,0,7,1,0);
     
451.                         };
     
452.         }
     
453. }
     
454. void trans(uchar z,uint speed)
     
455. {
     
456.         uchar i,j;
     
457.         for (j=0;j<8;j++)
     
458.         {
     
459.                 for (i=0;i<8;i++)
     
460.                 {
     
461.                         display[z][i]>>=1;
     
462.                 }
     
463.                 delay(speed);
     
464.         }
     
465. }
     
466. void tranoutchar(uchar c,uint speed)
     
467. {
     
468.         uchar i,j,k,a,i2=0;
     
469.         for (i=0;i<8;i++)
     
470.         {
     
471.                 if (i<7)
     
472.                 box_apeak_xy (i+1,0,0,i+1,7,7,1,1);
     
473.                 box_apeak_xy (i2,0,0,i2,7,7,1,0);
     
474.                 a=0;
     
475.                 i2=i+1;
     
476.                 for (j=0;j<=i;j++)
     
477.                 {
     
478.                         a=a|(1<<j);
     
479.                 }
     
480.                 for (k=0;k<8;k++)
     
481.                 {
     
482.                         display[k][3]|=table_cha[c][k]&a;
     
483.                         display[k][4]|=table_cha[c][k]&a;
     
484.                 }
     
485.                 delay(speed);
     
486.         }
     
487. }
     
488. void transss()
     
489. {
     
490.         uchar i,j;
     
491.         for (i=0;i<8;i++)
     
492.         {
     
493.                 for (j=0;j<8;j++)
     
494.                 display[i][j]<<=1;
     
495.         }
     
496. }
     
497. 
     
498. /*From now on,the function below is to display the flash.*/
     
499. void flash_1()
     
500. {
     
501. 
     
502. //        box(0,0,0,7,7,7,1,1);
     
503. //        while(1);
     
504.         clear(0);
     
505.         type(1,0);
     
506.         delay(60000);
     
507.         type(2,0);
     
508.         delay(60000);
     
509.         type(3,0);
     
510.         delay(60000);
     
511.         type(4,0);
     
512.         delay(60000);
     
513.         delay(60000);
     
514.         clear(0);
     
515.         rolldisplay(30000);
     
516.         type(0,7);
     
517.         delay(60000);
     
518.         trailler(6000);
     
519.         delay(60000);
     
520. }
     
521. void flash_2()
     
522. {
     
523.         uchar i;
     
524.         for (i=129;i>0;i--)
     
525.         {
     
526.                 cirp(i-2,0,1);
     
527.                 delay(8000);
     
528.                 cirp(i-1,0,0);
     
529.         }
     
530.         delay(8000);       
     
531.         for (i=0;i<136;i++)
     
532.         {
     
533.                 cirp(i,1,1);
     
534.                 delay(8000);
     
535.                 cirp(i-8,1,0);
     
536.         }
     
537.         delay(8000);
     
538.                 for (i=129;i>0;i--)
     
539.         {
     
540.                 cirp(i-2,0,1);
     
541.                 delay(8000);
     
542.         }
     
543.         delay(8000);
     
544.                 for (i=0;i<128;i++)
     
545.         {
     
546.                 cirp(i-8,1,0);
     
547.                 delay(8000);
     
548.         }
     
549.         delay(60000);       
     
550. }
     
551. void flash_3()
     
552. {
     
553.         char i;
     
554.         for (i=0;i<8;i++)
     
555.         {
     
556.                 box_apeak_xy(0,i,0,7,i,7,1,1);
     
557.                 delay(20000);
     
558.                 if (i<7)
     
559.                 box_apeak_xy(0,i,0,7,i,7,1,0);
     
560.         }
     
561.         for (i=7;i>=0;i--)
     
562.         {
     
563.                 box_apeak_xy(0,i,0,7,i,7,1,1);
     
564.                 delay(20000);
     
565.                 if (i>0)
     
566.                 box_apeak_xy(0,i,0,7,i,7,1,0);
     
567.         }
     
568.         for (i=0;i<8;i++)
     
569.         {
     
570.                 box_apeak_xy(0,i,0,7,i,7,1,1);
     
571.                 delay(20000);
     
572.                 if (i<7)
     
573.                 box_apeak_xy(0,i,0,7,i,7,1,0);
     
574.         }
     
575. }
     
576. void flash_4()
     
577. {
     
578.         char i,j,an[8];
     
579.         for (j=7;j<15;j++)
     
580.                 an[j-7]=j;
     
581.         for (i=0;i<=16;i++)
     
582.         {
     
583.                 for (j=0;j<8;j++)
     
584.                 {
     
585.                         if ((an[j]<8)&(an[j]>=0))
     
586.                         line(0,an[j],j,7,an[j],j,1);
     
587.                 }
     
588.                 for (j=0;j<8;j++)
     
589.                 {
     
590.                         if (((an[j]+1)<8)&(an[j]>=0))
     
591.                         line(0,an[j]+1,j,7,an[j]+1,j,0);
     
592.                 }
     
593.                 for (j=0;j<8;j++)
     
594.                 {
     
595.                         if (an[j]>0)
     
596.                         an[j]--;
     
597.                 }
     
598.                 delay(15000);
     
599.         }
     
600.         for (j=0;j<8;j++)
     
601.                 an[j]=1-j;
     
602.         for (i=0;i<=16;i++)
     
603.         {
     
604.                 for (j=0;j<8;j++)
     
605.                 {
     
606.                         if ((an[j]<8)&(an[j]>=0))
     
607.                         line(0,an[j],j,7,an[j],j,1);
     
608.                 }
     
609.                 for (j=0;j<8;j++)
     
610.                 {
     
611.                         if (((an[j]-1)<7)&(an[j]>0))
     
612.                         line(0,an[j]-1,j,7,an[j]-1,j,0);
     
613.                 }
     
614.                 for (j=0;j<8;j++)
     
615.                 {
     
616.                         if (an[j]<7)
     
617.                         an[j]++;
     
618.                 }
     
619.                 delay(15000);
     
620.         }
     
621. }
     
622. void flash_5()
     
623. {
     
624.         uint a=15000;//a=delay
     
625.         char i=8,j,an[4];
     
626.         //1
     
627.         for (j=7;j<11;j++)
     
628.                 an[j-7]=j;
     
629.         while(i--)
     
630.         {
     
631.                 for (j=0;j<4;j++)
     
632.                 {
     
633.                         if (an[j]<8)
     
634.                         box_apeak_xy(j,an[j],j,7-j,an[j],7-j,0,1);
     
635.                         if (an[j]<7)
     
636.                         box_apeak_xy(j,an[j]+1,j,7-j,an[j]+1,7-j,0,0);
     
637.                 }
     
638.                 for (j=0;j<4;j++)
     
639.                 {
     
640.                         if (an[j]>3)
     
641.                         an[j]--;
     
642.                 }
     
643.                 delay(a);
     
644.         }
     
645.         //2
     
646.         i=3;
     
647.         for (j=0;j<4;j++)
     
648.         an[j]=5-j;
     
649.         while(i--)
     
650.         {
     
651.                 for (j=1;j<4;j++)
     
652.                 {
     
653.                         if (an[j]<4)
     
654.                         box_apeak_xy(j,an[j],j,7-j,an[j],7-j,0,1);
     
655.                         if (an[j]<3)
     
656.                         box_apeak_xy(j,an[j]+1,j,7-j,an[j]+1,7-j,0,0);
     
657.                 }
     
658.                 for (j=0;j<4;j++)
     
659.                 {
     
660.                         if (an[j]>0)
     
661.                         an[j]--;
     
662.                 }
     
663.                 delay(a);
     
664.         }
     
665.         //3
     
666.         i=3;
     
667.         for (j=1;j<4;j++)
     
668.         an[j]=4-j;
     
669.         while(i--)
     
670.         {
     
671.                 for (j=1;j<4;j++)
     
672.                 {
     
673.                         if (an[j]>=0)
     
674.                         box_apeak_xy(j,an[j],j,7-j,an[j],7-j,0,1);
     
675.                         if (an[j]>0)
     
676.                         box_apeak_xy(j,an[j]-1,j,7-j,an[j]-1,7-j,0,0);
     
677.                 }
     
678.                 for (j=1;j<4;j++)
     
679.                 {
     
680.                         if (an[j]<3)
     
681.                         an[j]++;
     
682.                 }
     
683.                 delay(a);
     
684.         }
     
685. 
     
686.         //4
     
687.         i=3;
     
688.         for (j=0;j<4;j++)
     
689.         an[j]=j+1;
     
690.         while(i--)
     
691.         {
     
692.                 for (j=1;j<4;j++)
     
693.                 {
     
694.                         if (an[j]>3)
     
695.                         box_apeak_xy(j,an[j],j,7-j,an[j],7-j,0,1);
     
696.                         if (an[j]>3)
     
697.                         box_apeak_xy(j,an[j]-1,j,7-j,an[j]-1,7-j,0,0);
     
698.                 }
     
699.                 for (j=0;j<4;j++)
     
700.                         an[j]++;
     
701.                 delay(a);
     
702.         }
     
703.         //5
     
704.         i=3;
     
705.         for (j=3;j<6;j++)
     
706.                 an[j-2]=j;
     
707.         while(i--)
     
708.         {
     
709.                 for (j=1;j<4;j++)
     
710.                 {
     
711.                         box_apeak_xy(j,an[j],j,7-j,an[j],7-j,0,1);
     
712.                         box_apeak_xy(j,an[j]+1,j,7-j,an[j]+1,7-j,0,0);
     
713.                 }
     
714.                 for (j=0;j<4;j++)
     
715.                 {
     
716.                         if (an[j]>3)
     
717.                         an[j]--;
     
718.                 }
     
719.                 delay(a);
     
720.         }
     
721.         //6
     
722.         i=3;
     
723.         for (j=0;j<4;j++)
     
724.         an[j]=5-j;
     
725.         while(i--)
     
726.         {
     
727.                 for (j=1;j<4;j++)
     
728.                 {
     
729.                         if (an[j]<4)
     
730.                         box_apeak_xy(j,an[j],j,7-j,an[j],7-j,0,1);
     
731.                         if (an[j]<3)
     
732.                         box_apeak_xy(j,an[j]+1,j,7-j,an[j]+1,7-j,0,0);
     
733.                 }
     
734.                 for (j=0;j<4;j++)
     
735.                 {
     
736.                         if (an[j]>0)
     
737.                         an[j]--;
     
738.                 }
     
739.                 delay(a);
     
740.         }
     
741.         //7
     
742.         i=3;
     
743.         for (j=0;j<4;j++)
     
744.         an[j]=3-j;
     
745.         an[0]=2;
     
746.         while(i--)
     
747.         {
     
748.                 for (j=0;j<3;j++)
     
749.                 {
     
750.                         if (an[j]>=0)
     
751.                                 box_apeak_xy(j,an[j],j,7-j,an[j],7-j,0,1);
     
752.                         if (an[j]>=0)
     
753.                                 box_apeak_xy(j,an[j]+1,j,7-j,an[j]+1,7-j,0,0);
     
754.                 }
     
755.                 for (j=0;j<4;j++)
     
756.                 {
     
757.                         if (j<5-i)
     
758.                         an[j]--;
     
759.                 }
     
760.                 delay(a);
     
761.         }
     
762.         //8
     
763.         i=10;
     
764.         for (j=0;j<4;j++)
     
765.                 an[j]=j-2;
     
766.         while(i--)
     
767.         {
     
768.                 for (j=0;j<4;j++)
     
769.                 {
     
770.                         if (an[j]>=0)
     
771.                         box_apeak_xy(j,an[j],j,7-j,an[j],7-j,0,1);
     
772.                         if (an[j]>=0)
     
773.                         box_apeak_xy(j,an[j]-1,j,7-j,an[j]-1,7-j,0,0);
     
774.                 }
     
775.                 for (j=0;j<4;j++)
     
776.                 {
     
777.                         if (an[j]<7)
     
778.                         an[j]++;
     
779.                 }
     
780.                 delay(a);
     
781.         }
     
782. }
     
783. void flash_6()
     
784. {
     
785.         uchar i,j,k,z;
     
786.         roll_apeak_yz(1,10000);
     
787.         roll_apeak_yz(2,10000);
     
788.         roll_apeak_yz(3,10000);
     
789.         roll_apeak_yz(0,10000);
     
790.         roll_apeak_yz(1,10000);
     
791.         roll_apeak_yz(2,10000);
     
792.         roll_apeak_yz(3,10000);
     
793.         for (i=0;i<3;i++)
     
794.                 {
     
795.                         for (j=0;j<8;j++)
     
796.                         {
     
797.                                 for (k=0;k<8;k++)
     
798.                                 {
     
799.                                         if ((table_3p[i][j]>>k)&1)
     
800.                                         {
     
801.                                                 for (z=1;z<8;z++)
     
802.                                                         {
     
803.                                                                 point (j,7-k,z,1);
     
804.                                                                 if (z-1)
     
805.                                                                 point (j,7-k,z-1,0);
     
806.                                                                 delay(5000);
     
807.                                                         }
     
808.                                         }
     
809.                                 }
     
810.                         }
     
811.                         trans(7,15000);
     
812.                 }
     
813. }
     
814. void flash_7()
     
815. {
     
816.         uchar i;
     
817.         uint a=3000;
     
818.         roll_apeak_yz(0,10000);
     
819.         roll_apeak_yz(1,10000);
     
820.         roll_apeak_yz(2,10000);
     
821.         roll_apeak_yz(3,10000);
     
822.         roll_apeak_yz(0,10000);
     
823.         roll_apeak_yz(1,10000);
     
824.         roll_apeak_yz(2,10000);
     
825.         roll_apeak_yz(3,10000);
     
826.         roll_apeak_yz(0,10000);
     
827.         roll_apeak_yz(1,10000);
     
828.         roll_apeak_yz(2,10000);
     
829.         roll_apeak_xy(0,10000);
     
830.         roll_apeak_xy(1,10000);
     
831.         roll_apeak_xy(2,10000);
     
832.         roll_apeak_xy(3,10000);
     
833.         roll_apeak_xy(0,10000);
     
834.         roll_apeak_xy(1,10000);
     
835.         roll_apeak_xy(2,10000);
     
836.         roll_apeak_xy(3,10000);
     
837.         for (i=0;i<8;i++)
     
838.         {
     
839.                 box_apeak_xy (0,i,0,7-i,i,7,1,1);
     
840.                 delay(a);
     
841.         }
     
842.         delay(30000);
     
843.         roll_3_xy(0,a);
     
844.         delay(30000);
     
845.         roll_3_xy(1,a);
     
846.         delay(30000);
     
847.         roll_3_xy(2,a);
     
848.         delay(30000);
     
849.         roll_3_xy(3,a);
     
850.         delay(30000);
     
851.         roll_3_xy(0,a);
     
852.         delay(30000);
     
853.         roll_3_xy(1,a);
     
854.         delay(30000);
     
855.         roll_3_xy(2,a);
     
856.         delay(30000);
     
857.         roll_3_xy(3,a);
     
858.         for (i=7;i>0;i--)
     
859.         {
     
860.                 box_apeak_xy(i,0,0,i,7,7,1,0);
     
861.                 delay(a);
     
862.         }
     
863. }
     
864. void flash_8()
     
865. {
     
866.         uchar i;
     
867.         for (i=5;i<8;i++)
     
868.         {
     
869.                 tranoutchar(i,10000);
     
870.                 delay(60000);
     
871.                 delay(60000);
     
872.         }
     
873. }
     
874. void flash_9()
     
875. {
     
876.         char i;
     
877.         uchar j,an[8],x,y,t,x1,y1;
     
878.         for (i=0;i<8;i++)
     
879.         {
     
880.                 box_apeak_xy (i,0,0,i,7,7,1,1);
     
881.                 if (i)
     
882.                 box_apeak_xy (i-1,0,0,i-1,7,7,1,0);
     
883.                 delay(10000);
     
884.         }
     
885.         roll_apeak_xy(3,10000);
     
886.         roll_apeak_xy(0,10000);
     
887.         roll_apeak_xy(1,10000);
     
888.         for (i=0;i<7;i++)
     
889.         {
     
890.                 line(6-i,6-i,0,6-i,6-i,7,1);
     
891.                 line(i,7,0,i,7,7,0);
     
892.                 delay(10000);
     
893.         }
     
894.         for (i=0;i<8;i++)
     
895.                 an[i]=14;
     
896.         for (i=0;i<85;i++)
     
897.         {
     
898.                 clear(0);
     
899.                 for (j=0;j<8;j++)
     
900.                 {
     
901.                         t=an[j]%28;
     
902.                         x=dat2[t]>>5;
     
903.                         y=(dat2[t]>>2)&0x07;
     
904.                         t=(an[j]-14)%28;
     
905.                         x1=dat2[t]>>5;
     
906.                         y1=(dat2[t]>>2)&0x07;
     
907.                         line(x,y,j,x1,y1,j,1);
     
908.                 }
     
909.                 for (j=0;j<8;j++)
     
910.                 {
     
911.                 if ((i>j)&(j>i-71))
     
912.                 an[j]++;
     
913.                 }
     
914.                 delay(5000);
     
915.         }
     
916.         for (i=0;i<85;i++)
     
917.         {
     
918.                 clear(0);
     
919.                 for (j=0;j<8;j++)
     
920.                 {
     
921.                         t=an[j]%28;
     
922.                         x=dat2[t]>>5;
     
923.                         y=(dat2[t]>>2)&0x07;
     
924.                         t=(an[j]-14)%28;
     
925.                         x1=dat2[t]>>5;
     
926.                         y1=(dat2[t]>>2)&0x07;
     
927.                         line(x,y,j,x1,y1,j,1);
     
928.                 }
     
929.                 for (j=0;j<8;j++)
     
930.                 {
     
931.                 if ((i>j)&(j>i-71))
     
932.                 an[j]--;
     
933.                 }
     
934.                 delay(5000);
     
935.         }
     
936.         for (i=0;i<29;i++)
     
937.         {
     
938.                 clear(0);
     
939. 
     
940.                 t=an[0]%28;
     
941.                 x=dat2[t]>>5;
     
942.                 y=(dat2[t]>>2)&0x07;
     
943.                 t=(an[0]-14)%28;
     
944.                 x1=dat2[t]>>5;
     
945.                 y1=(dat2[t]>>2)&0x07;
     
946.                 box_apeak_xy(x,y,0,x1,y1,7,0,1);
     
947.                 box_apeak_xy(x,y,1,x1,y1,6,0,1);
     
948.                 an[0]++;
     
949.                 delay(5000);
     
950.         }
     
951.         for (i=0;i<16;i++)
     
952.         {
     
953.                 clear(0);
     
954. 
     
955.                 t=an[0]%28;
     
956.                 x=dat2[t]>>5;
     
957.                 y=(dat2[t]>>2)&0x07;
     
958.                 t=(an[0]-14)%28;
     
959.                 x1=dat2[t]>>5;
     
960.                 y1=(dat2[t]>>2)&0x07;
     
961.                 box_apeak_xy(x,y,0,x1,y1,7,1,1);
     
962.                 an[0]--;
     
963.                 delay(5000);
     
964.         }
     
965.         for (i=0;i<8;i++)
     
966.         {
     
967.                 line(i,i,0,0,0,i,0);
     
968.                 delay(5000);
     
969.         }
     
970.         for (i=1;i<7;i++)
     
971.         {
     
972.                 line(i,i,7,7,7,i,0);
     
973.                 delay(5000);
     
974.         }
     
975.         for (i=1;i<8;i++)
     
976.         {
     
977.                 clear(0);
     
978.                 box(7,7,7,7-i,7-i,7-i,0,1);
     
979.                 delay(10000);
     
980.         }
     
981.         for (i=1;i<7;i++)
     
982.         {
     
983.                 clear(0);
     
984.                 box(0,0,0,7-i,7-i,7-i,0,1);
     
985.                 delay(10000);
     
986.         }
     
987.         for (i=1;i<8;i++)
     
988.         {
     
989.                 clear(0);
     
990.                 box(0,0,0,i,i,i,0,1);
     
991.                 delay(10000);
     
992.         }
     
993.         for (i=1;i<7;i++)
     
994.         {
     
995.                 clear(0);
     
996.                 box(7,0,0,i,7-i,7-i,0,1);
     
997.                 delay(10000);
     
998.         }
     
999.         for (i=1;i<8;i++)
     
1000.         {
      
1001.                 box(7,0,0,7-i,i,i,1,1);
      
1002.                 delay(10000);
      
1003.         }
      
1004.         for (i=1;i<7;i++)
      
1005.         {
      
1006.                 clear(0);
      
1007.                 box(0,7,7,7-i,i,i,1,1);
      
1008.                 delay(10000);
      
1009.         }
      
1010. }
      
1011. void flash_10()
      
1012. {
      
1013.         uchar i,j,an[4],x,y,t;
      
1014.         for (i=1;i<7;i++)
      
1015.         {
      
1016.                
      
1017.                 clear(0);
      
1018.                 box(0,6,6,1,7,7,1,1);
      
1019.                 box(i,6,6-i,i+1,7,7-i,1,1);
      
1020.                 box(i,6,6,i+1,7,7,1,1);
      
1021.                 box(0,6,6-i,1,7,7-i,1,1);
      
1022.                 box(0,6-i,6,1,7-i,7,1,1);
      
1023.                 box(i,6-i,6-i,i+1,7-i,7-i,1,1);
      
1024.                 box(i,6-i,6,i+1,7-i,7,1,1);
      
1025.                 box(0,6-i,6-i,1,7-i,7-i,1,1);
      
1026.                 delay(30000);
      
1027.         }
      
1028.         for (i=0;i<4;i++)
      
1029.         {
      
1030.                 an[i]=6*i;
      
1031.         }
      
1032.         for (i=0;i<35;i++)
      
1033.         {
      
1034.                 clear(0);
      
1035.                 for(j=0;j<4;j++)
      
1036.                 {
      
1037.                         t=an[j]%24;
      
1038.                         x=dat3[t]>>4;
      
1039.                         y=dat3[t]&0x0f;
      
1040.                         box(x,y,0,x+1,y+1,1,1,1);
      
1041.                         box(x,y,6,x+1,y+1,7,1,1);
      
1042.                 }
      
1043.                 for (j=0;j<4;j++)
      
1044.                 an[j]++;
      
1045.                 delay(10000);
      
1046.         }
      
1047.         for (i=0;i<35;i++)
      
1048.         {
      
1049.                 clear(0);
      
1050.                 for(j=0;j<4;j++)
      
1051.                 {
      
1052.                         t=an[j]%24;
      
1053.                         x=dat3[t]>>4;
      
1054.                         y=dat3[t]&0x0f;
      
1055.                         box(x,y,0,x+1,y+1,1,1,1);
      
1056.                         box(x,y,6,x+1,y+1,7,1,1);
      
1057.                 }
      
1058.                 for (j=0;j<4;j++)
      
1059.                 an[j]--;
      
1060.                 delay(10000);
      
1061.         }
      
1062.         for (i=0;i<35;i++)
      
1063.         {
      
1064.                 clear(0);
      
1065.                 for(j=0;j<4;j++)
      
1066.                 {
      
1067.                         t=an[j]%24;
      
1068.                         x=dat3[t]>>4;
      
1069.                         y=dat3[t]&0x0f;
      
1070.                         box(x,0,y,x+1,1,y+1,1,1);
      
1071.                         box(x,6,y,x+1,7,y+1,1,1);
      
1072.                 }
      
1073.                 for (j=0;j<4;j++)
      
1074.                 an[j]++;
      
1075.                 delay(10000);
      
1076.         }
      
1077.         for (i=0;i<36;i++)
      
1078.         {
      
1079.                 clear(0);
      
1080.                 for(j=0;j<4;j++)
      
1081.                 {
      
1082.                         t=an[j]%24;
      
1083.                         x=dat3[t]>>4;
      
1084.                         y=dat3[t]&0x0f;
      
1085.                         box(x,0,y,x+1,1,y+1,1,1);
      
1086.                         box(x,6,y,x+1,7,y+1,1,1);
      
1087.                 }
      
1088.                 for (j=0;j<4;j++)
      
1089.                 an[j]--;
      
1090.                 delay(10000);
      
1091.         }
      
1092.         for (i=6;i>0;i--)
      
1093.         {
      
1094.                
      
1095.                 clear(0);
      
1096.                 box(0,6,6,1,7,7,1,1);
      
1097.                 box(i,6,6-i,i+1,7,7-i,1,1);
      
1098.                 box(i,6,6,i+1,7,7,1,1);
      
1099.                 box(0,6,6-i,1,7,7-i,1,1);
      
1100.                 box(0,6-i,6,1,7-i,7,1,1);
      
1101.                 box(i,6-i,6-i,i+1,7-i,7-i,1,1);
      
1102.                 box(i,6-i,6,i+1,7-i,7,1,1);
      
1103.                 box(0,6-i,6-i,1,7-i,7-i,1,1);
      
1104.                 delay(30000);
      
1105.         }
      
1106. }
      
1107. void flash_11()
      
1108. {
      
1109.         uchar i,j,t,x,y;
      
1110.         uchar code daa[13]={0,1,2,0x23,5,6,7,6,5,0x23,2,1,0};
      
1111.         for (j=0;j<5;j++)
      
1112.         {
      
1113.                 for (i=0;i<13;i++)
      
1114.                 {
      
1115.                         if (daa[i]>>4)
      
1116.                         {
      
1117.                                 t=daa[i]&0x0f;
      
1118.                                 line (0,0,t+1,0,7,t+1,1);
      
1119.                         }
      
1120.                         else
      
1121.                                 t=daa[i];
      
1122.                         line (0,0,t,0,7,t,1);
      
1123.                         transss();
      
1124.                         delay(10000);
      
1125.                 }
      
1126.         }
      
1127.         for (j=1;j<8;j++)
      
1128.         {
      
1129.                 if (j>3)
      
1130.                         t=4;
      
1131.                 else
      
1132.                         t=j;
      
1133.                 for (i=0;i<24;i+=j)
      
1134.                 {
      
1135.                         x=dat3[i]>>4;
      
1136.                         y=dat3[i]&0x0f;
      
1137.                         box_apeak_xy(0,x,y,0,x+1,y+1,1,1);
      
1138.                         transss();
      
1139.                         delay(10000);
      
1140.                 }
      
1141.         }
      
1142.         for (j=1;j<8;j++)
      
1143.         {
      
1144.                 if (j>3)
      
1145.                         t=4;
      
1146.                 else
      
1147.                         t=j;
      
1148.                 for (i=0;i<24;i+=j)
      
1149.                 {
      
1150.                         x=dat3[i]>>4;
      
1151.                         y=dat3[i]&0x0f;
      
1152.                         point (0,x,y,1);
      
1153.                         transss();
      
1154.                         delay(10000);
      
1155.                 }
      
1156.         }
      
1157. }
      
1158. void main()
      
1159. {
      
1160.         sinter();
      
1161.         clear(0);
      
1162.         /*play list*/
      
1163.         flash_1();
      
1164.         clear(0);
      
1165.         flash_2();
      
1166.         flash_3();
      
1167.         flash_4();
      
1168.         flash_4();
      
1169.         flash_5();
      
1170.         flash_5();
      
1171.         flash_6();
      
1172.         flash_7();
      
1173.         flash_8();
      
1174.         flash_9();
      
1175.         flash_10();
      
1176.         clear (0);
      
1177.         flash_11();
      
1178.         flash_9();
      
1179.         flash_5();
      
1180.         flash_7();
      
1181.         flash_5();
      
1182.         flash_6();
      
1183.         flash_8();
      
1184.         flash_9();
      
1185.         flash_10();
      
1186.         while(1);
      
1187. }
      
1188. void print() interrupt 1
      
1189. {
      
1190.         char i;
      
1191.         static uchar layer=0;
      
1192. 
      
1193.         //          先发送层信息，层在最后一个595上所以要先发送
      
1194.         SBUF = 0x80>>layer;
      
1195.                 while(!TI)                   //如果发送完毕，硬件会置位TI
      
1196.                 {
      
1197.                         _nop_();       
      
1198.                 }
      
1199.                 TI = 0;
      
1200.         // 开始发送数据
      
1201.         for (i=7;i>=0;i--)
      
1202.         {
      
1203.                 SBUF = display[layer][i];
      
1204.                 while(!TI)                   //如果发送完毕，硬件会置位TI
      
1205.                 {
      
1206.                         _nop_();       
      
1207.                 }
      
1208.                 TI = 0;
      
1209.         }
      
1210.         STCP=1;
      
1211.         _nop_();
      
1212.         STCP=0;
      
1213.         if (layer<7)
      
1214.                 layer++;
      
1215.         else
      
1216.                 layer=0;
      
1217.         TH0=0xd0;
      
1218.         TL0=0;
      
1219. }
      

复制代码

谢谢分享

正需要，谢谢分享。。。。

谢谢谢谢11111

喜欢  想下载 谢谢楼主的贡献

谢谢贴主

这个真的很赞，谢谢楼主

好东西 果断收藏学习 非常感谢

谢谢分享

谢谢分享

感谢分享！~

谢谢分享

谢谢分享

谢谢楼主的分享！

最近做的毕设就是这个，恩，图看不清啊

很牛逼！！！！

谢谢 分享

感谢分享。。。请问PCB图要用什么打开

不错的资料 果断收藏学习 感谢楼主无私奉献

资源详细，一级棒，动手能力杠杠的。感谢楼主的奉献！

感谢分享 可是没有黑币下载啊

原理图的IO和程序的IO对不上，楼主的595的数据脚(14脚)接的是P3.0，将数据丢到SBUF发送出去只是操作P3.1(即595的11脚，数据移位脚)，望改正

谢谢分享

能有几张成品图看看就更好了

不错，多谢分享

不错，感谢分享

在哪下载资料

感谢楼主，之前的几个都没有给源文件，就你给了！！

可惜原理图PCB是protel99格式的,我没有

有个问题，单片机还有那么多IO口，为什么2803不直接接上去用呢？

真不错，最近要做这个光立方