16层彩色广州塔源程序

单片机测试程序：

1. 
   
2. #include<reg52.h>                         //头文件
   
3. #define uint unsigned int         //宏定义
   
4. #define uchar unsigned char         //宏定义
   
5. #include<intrins.h>                         //循环函数的头文件
   
6. uchar code table0[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};//从低位往高位灭一个灯流水
   
7. uchar code table1[]={0x7f,0xbf,0xdf,0xef,0xf7,0xfb,0xfd,0xfe};//从高位往低位灭一个灯流水
   
8. uchar code table2[]={0xfe,0xfa,0xf8,0xf0,0xe0,0xa0,0x80,0x00};//从低位到高位逐步全部熄灭
   
9. uchar code table3[]={0x7f,0x3f,0x1f,0x0f,0x07,0x03,0x01,0x00};//从高位到低位逐步全部熄灭
   
10. uchar code table4[]={0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f,0xff};//从低位到高位逐步全部点亮
    
11. uchar code table5[]={0x80,0xa0,0xe0,0xf0,0xf8,0xfa,0xfe,0xff};//从高位到低位逐步全部点亮
    
12. uchar code table6[]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};//从低位到高位，亮一个灯移动
    
13. uchar code table7[]={0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01};//从高位到低位，亮一个灯移动
    
14. 
    
15. uchar code table8[]={0xfc,0xfe,0xff,0x7f,0x3f,0x1f,0x0f,0x07,0x03,0x01,0x00,0x80,0xc0,0xe0,0xf0,0xf1};
    
16. uchar code table9[]={0x03,0x01,0x00,0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff,0x7f,0x3f,0x1f,0x0f,0x07};
    
17. 
    
18. uchar code table10[]={0x00,0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff,0x7f,0x3f,0x1f,0x0f,0x07,0x03,0x01};
    
19. uchar code table11[]={0xff,0x7f,0x3f,0x1f,0x0f,0x07,0x03,0x01,0x00,0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe};
    
20. 
    
21. uchar code table12[]={0x1f,0x0f,0x07,0x03,0x01,0x00,0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff,0x7f,0x3f};
    
22. uchar code table13[]={0xe0,0xf0,0xf8,0xfc,0xfe,0xff,0x7f,0x3f,0x1f,0x0f,0x07,0x03,0x01,0x00,0x80,0xc0};
    
23. 
    
24. 
    
25. uchar i,b;
    
26. 
    
27. 
    
28. sbit r1=P3^2; //红色上8层片选
    
29. sbit r2=P3^3; //红色下8层片选
    
30. sbit b1=P3^4; //绿色上8层片选
    
31. sbit b2=P3^5; //绿色下8层片选
    
32. sbit g1=P3^6; //蓝色上8层片选
    
33. sbit g2=P3^7; //蓝色下8层片选
    
34. 
    
35. void delay(uint z) //延时函数
    
36. {
    
37.         uint x,y;
    
38.         for(x=z;x>0;x--)
    
39.                 for(y=314;y>0;y--);
    
40. }
    
41. /******************************************/
    
42. void liushui0()//两列红色逆时针转动
    
43. {
    
44.         r1=1;        //开红色使能
    
45.         r2=1;        //开红色使能
    
46. 
    
47.         P0=0xff;//
    
48.         for(i=0;i<8;i++)
    
49.         {
    
50.                 P1=table6[i];
    
51.                 P2=table6[i];
    
52.                 delay(30);
    
53.         }
    
54.            P1=0x00;P2=0x00;
    
55.         P0=0x00;
    
56.         r1=0;  //关红色使能
    
57.         r2=0;  //关红色使能
    
58. }
    
59. void rr()//红色亮一会儿
    
60. {
    
61.         r1=1;
    
62.         r2=1;
    
63.         P0=0xff;
    
64.         P2=0xff;
    
65.         P1=0xff;
    
66.         delay(100);
    
67.         P0=0x00;
    
68.         r1=0;
    
69.         r2=0;
    
70.         P2=0x00;
    
71.         P1=0x00;
    
72. }
    
73. /******************************************/
    
74. void liushui1()//两列绿色逆时针转动
    
75. {
    
76.         g1=1;        //开绿色使能
    
77.         g2=1;        //开绿色使能
    
78. 
    
79.         P0=0xff;//
    
80.         for(i=0;i<8;i++)
    
81.         {
    
82.                 P1=table6[i];
    
83.                 P2=table6[i];
    
84.                 delay(30);
    
85.         }
    
86.            P1=0x00;P2=0x00;
    
87.         P0=0x00;
    
88.         g1=0;  //关绿色使能
    
89.         g2=0;  //关绿色使能
    
90. }
    
91. void gg()//绿色亮一会儿
    
92. {
    
93.         g1=1;
    
94.         g2=1;
    
95.         P0=0xff;
    
96.         P2=0xff;
    
97.         P1=0xff;
    
98.         delay(100);
    
99.         P0=0x00;
    
100.         g1=0;
     
101.         g2=0;
     
102.         P2=0x00;
     
103.         P1=0x00;
     
104. }
     
105. /******************************************/
     
106. void liushui2()//两列蓝色逆时针转动
     
107. {
     
108.         b1=1;        //开蓝色使能
     
109.         b2=1;        //开蓝色使能
     
110. 
     
111.         P0=0xff;//
     
112.         for(i=0;i<8;i++)
     
113.         {
     
114.                 P1=table6[i];
     
115.                 P2=table6[i];
     
116.                 delay(30);
     
117.         }
     
118.            P1=0x00;P2=0x00;
     
119.         P0=0x00;
     
120.         b1=0;  //关蓝色使能
     
121.         b2=0;  //关蓝色使能
     
122. }
     
123. void bb()//蓝色亮一会儿
     
124. {
     
125.         b1=1;
     
126.         b2=1;
     
127.         P0=0xff;
     
128.         P2=0xff;
     
129.         P1=0xff;
     
130.         delay(100);
     
131.         P0=0x00;
     
132.         b1=0;
     
133.         b2=0;
     
134.         P2=0x00;
     
135.         P1=0x00;
     
136. }
     
137. void liushui3()//红色单层向上移动
     
138. {
     
139.         P1=0xff;P2=0xff;
     
140.         b2=1;
     
141.         for(i=0;i<8;i++)
     
142.         {
     
143.                 P0=table7[i];
     
144.                 delay(30);
     
145.         }
     
146.         P0=0x00;
     
147.         b2=0;
     
148. /********* **********/
     
149.         P1=0xff;P2=0xff;
     
150.         b1=1;
     
151.         for(i=0;i<8;i++)
     
152.         {
     
153.                 P0=table7[i];
     
154.                 delay(30);
     
155.         }
     
156.         P0=0x00;
     
157.         b1=0;
     
158. }
     
159. /***********************/
     
160. void liushui4()//红、黄、绿、青、蓝、洋红、白、红，向上流动
     
161. {
     
162.         uchar a,b,c;//绿、红、蓝
     
163. 
     
164. 
     
165.         a=0x8d;
     
166.         b=0x38;
     
167.         c=0xe1;
     
168. /////////////
     
169. 
     
170.         r1=1;P0=b;r1=0;
     
171.         r2=1;P0=b;r2=0;
     
172. 
     
173.         g1=1;P0=a;g1=0;
     
174.         g2=1;P0=a;g2=0;
     
175. 
     
176.         b1=1;P0=c;b1=0;
     
177.         b2=1;P0=c;b2=0;
     
178. 
     
179.         P1=0xff;P2=0xff;
     
180. 
     
181.         for(i=0;i<8;i++)
     
182.         {
     
183.                 a=_cror_(a,1);//循环左移
     
184.                 b=_cror_(b,1);//循环左移
     
185.                 c=_cror_(c,1);//循环左移
     
186.                 delay(80);//延时
     
187.         r1=1;P0=b;r1=0;
     
188.         r2=1;P0=b;r2=0;
     
189. 
     
190.         g1=1;P0=a;g1=0;
     
191.         g2=1;P0=a;g2=0;
     
192. 
     
193.         b1=1;P0=c;b1=0;
     
194.         b2=1;P0=c;b2=0;
     
195. 
     
196.         }
     
197.         P3=0xff;P0=0x00;P3=0x00;
     
198.         P1=0x00;P2=0x00;
     
199. 
     
200. }
     
201. 
     
202. /*************************************************/
     
203. void liushui5()//红、黄、绿、青、蓝、洋红、白、红，向下流动
     
204. {
     
205.         uchar a,b,c;//绿、红、蓝
     
206. 
     
207. 
     
208.         a=0x8d;
     
209.         b=0x38;
     
210.         c=0xe1;
     
211. /////////////
     
212. 
     
213.         r1=1;P0=b;r1=0;
     
214.         r2=1;P0=b;r2=0;
     
215. 
     
216.         g1=1;P0=a;g1=0;
     
217.         g2=1;P0=a;g2=0;
     
218. 
     
219.         b1=1;P0=c;b1=0;
     
220.         b2=1;P0=c;b2=0;
     
221. 
     
222.         P1=0xff;P2=0xff;
     
223. 
     
224.         for(i=0;i<8;i++)
     
225.         {
     
226.                 a=_crol_(a,1);//循环左移
     
227.                 b=_crol_(b,1);//循环左移
     
228.                 c=_crol_(c,1);//循环左移
     
229.                 delay(80);//延时
     
230.         r1=1;P0=b;r1=0;
     
231.         r2=1;P0=b;r2=0;
     
232. 
     
233.         g1=1;P0=a;g1=0;
     
234.         g2=1;P0=a;g2=0;
     
235. 
     
236.         b1=1;P0=c;b1=0;
     
237.         b2=1;P0=c;b2=0;
     
238. 
     
239.         }
     
240.         P3=0xff;P0=0x00;P3=0x00;
     
241.         P1=0x00;P2=0x00;
     
242. 
     
243. }
     
244. void liushui6()//白色单层向上
     
245. {
     
246.         uchar a,b,c;//绿、红、蓝
     
247. 
     
248. 
     
249.         a=0x80;
     
250.         b=0x80;
     
251.         c=0x80;
     
252. /////////////
     
253. 
     
254.         r2=1;P0=b;r2=0;
     
255.         g2=1;P0=a;g2=0;
     
256.         b2=1;P0=c;b2=0;
     
257. 
     
258.         P1=0xff;P2=0xff;
     
259. 
     
260.         for(i=0;i<8;i++)
     
261.         {
     
262.                 a=_cror_(a,1);//循环左移
     
263.                 b=_cror_(b,1);//循环左移
     
264.                 c=_cror_(c,1);//循环左移
     
265.                 delay(25);//延时
     
266. 
     
267.         r2=1;P0=b;r2=0;
     
268.         g2=1;P0=a;g2=0;
     
269.         b2=1;P0=c;b2=0;
     
270. 
     
271.         }
     
272.         P3=0xff;P0=0x00;P3=0x00;
     
273.         P1=0x00;P2=0x00;
     
274. /*****************************************/
     
275.         r1=1;P0=b;r1=0;
     
276.         g1=1;P0=a;g1=0;
     
277.         b1=1;P0=c;b1=0;
     
278. 
     
279.         P1=0xff;P2=0xff;
     
280. 
     
281.         for(i=0;i<8;i++)
     
282.         {
     
283.                 a=_cror_(a,1);//循环左移
     
284.                 b=_cror_(b,1);//循环左移
     
285.                 c=_cror_(c,1);//循环左移
     
286.                 delay(25);//延时
     
287. 
     
288.         r1=1;P0=b;r1=0;
     
289.         g1=1;P0=a;g1=0;
     
290.         b1=1;P0=c;b1=0;
     
291. 
     
292.         }
     
293.         P3=0xff;P0=0x00;P3=0x00;
     
294.         P1=0x00;P2=0x00;
     
295. }
     
296. /****************************************************/
     
297. void liushui7()//白色单层向下
     
298. {
     
299.         uchar a,b,c;//绿、红、蓝
     
300. 
     
301. 
     
302.         a=0x01;
     
303.         b=0x01;
     
304.         c=0x01;
     
305. /////////////
     
306. 
     
307. 
     
308.         r1=1;P0=b;r1=0;
     
309.         g1=1;P0=a;g1=0;
     
310.         b1=1;P0=c;b1=0;
     
311. 
     
312.         P1=0xff;P2=0xff;
     
313. 
     
314.         for(i=0;i<8;i++)
     
315.         {
     
316.                 a=_crol_(a,1);//循环左移
     
317.                 b=_crol_(b,1);//循环左移
     
318.                 c=_crol_(c,1);//循环左移
     
319.                 delay(25);//延时
     
320. 
     
321.         r1=1;P0=b;r1=0;
     
322.         g1=1;P0=a;g1=0;
     
323.         b1=1;P0=c;b1=0;
     
324. 
     
325.         }
     
326.         P3=0xff;P0=0x00;P3=0x00;
     
327.         P1=0x00;P2=0x00;
     
328. /*****************************************/        
     
329.         r2=1;P0=b;r2=0;
     
330.         g2=1;P0=a;g2=0;
     
331.         b2=1;P0=c;b2=0;
     
332. 
     
333.         P1=0xff;P2=0xff;
     
334. 
     
335.         for(i=0;i<8;i++)
     
336.         {
     
337.                 a=_crol_(a,1);//循环左移
     
338.                 b=_crol_(b,1);//循环左移
     
339.                 c=_crol_(c,1);//循环左移
     
340.                 delay(25);//延时
     
341. 
     
342.         r2=1;P0=b;r2=0;
     
343.         g2=1;P0=a;g2=0;
     
344.         b2=1;P0=c;b2=0;
     
345. 
     
346.         }
     
347.         P3=0xff;P0=0x00;P3=0x00;
     
348.         P1=0x00;P2=0x00;
     
349. }
     
350. /********************************************************************/
     
351. void liushui8()//6色向上流动
     
352. {
     
353.         P1=0x00;P2=0x00;
     
354.         P1=0xff;P2=0xff;
     
355.         for(i=0;i<16;i++)
     
356.         {
     
357.                 r2=1;P0=table8[i];r2=0;
     
358.                 r1=1;P0=table9[i];r1=0;
     
359.         P1=0x00;P2=0x00;
     
360.         P1=0xff;P2=0xff;
     
361.                 /******/
     
362.                 g2=1;P0=table10[i];g2=0;
     
363.                 g1=1;P0=table11[i];g1=0;
     
364. 
     
365.         P1=0x00;P2=0x00;
     
366.         P1=0xff;P2=0xff;
     
367. 
     
368.                 b2=1;P0=table12[i];b2=0;
     
369.                 b1=1;P0=table13[i];b1=0;
     
370.                 delay(25);
     
371.         }
     
372. 
     
373.         P3=0xff;P0=0x00;P3=0x00;
     
374. }
     
375. /***********************************************************************/
     
376. void liushui9()//6色向下流动
     
377. {
     
378.         P1=0x00;P2=0x00;
     
379.         P1=0xff;P2=0xff;
     
380.         for(i=16;i>0;i--)
     
381.         {
     
382.                 r2=1;P0=table8[i];r2=0;
     
383.                 r1=1;P0=table9[i];r1=0;
     
384.         P1=0x00;P2=0x00;
     
385.         P1=0xff;P2=0xff;
     
386.                 /******/
     
387.                 g2=1;P0=table10[i];g2=0;
     
388.                 g1=1;P0=table11[i];g1=0;
     
389. 
     
390.         P1=0x00;P2=0x00;
     
391.         P1=0xff;P2=0xff;
     
392. 
     
393.                 b2=1;P0=table12[i];b2=0;
     
394.                 b1=1;P0=table13[i];b1=0;
     
395.                 delay(25);
     
396.         }
     
397. 
     
398.         P3=0xff;P0=0x00;P3=0x00;
     
399. }
     
400. /********************************************************************************
     
401. *********************************************************************************
     
402. *********************************************************************************/
     
403. void main()
     
404. {
     
405.         r1=1;P0=0x80;r1=0;
     
406.         r2=1;P0=0x80;r2=0;
     
407. 
     
408.         g1=1;P0=0x00;g1=0;
     
409.         g2=1;P0=0x00;g2=0;
     
410. 
     
411.         b1=1;P0=0x00;b1=0;
     
412.         b2=1;P0=0x00;b2=0;
     
413.         P1=0x00;
     
414.         P2=0x00;
     
415. /**************************************/
     
416. 
     
417. while(1)
     
418.          {
     
419. /*        */
     
420.           liushui0();//两列红色逆时针转动
     
421.           liushui1();//两列绿色逆时针转动
     
422.           liushui2();//两列蓝色逆时针转动
     
423.           liushui3();//红色单层向上移动
     
424.          
     
425. //          gg();//绿色亮一会儿
     
426. //          rr();//红色亮一会儿
     
427. //          bb();//蓝色亮一会儿
     
428. //
     
429. //          liushui4();//红、黄、绿、青、蓝、洋红、白、红，向上流动
     
430. //          liushui4();//红、黄、绿、青、蓝、洋红、白、红，向上流动
     
431. //          liushui4();//红、黄、绿、青、蓝、洋红、白、红，向上流动
     
432. //
     
433. //          liushui5();//红、黄、绿、青、蓝、洋红、白、红，向下流动
     
434. //          liushui5();//红、黄、绿、青、蓝、洋红、白、红，向下流动
     
435. //          liushui5();//红、黄、绿、青、蓝、洋红、白、红，向下流动
     
436. //
     
437. //
     
438. //          liushui6();//白色单层向上
     
439. //          liushui7();//白色单层向下
     
440. //
     
441. //
     
442. //          liushui8();//6色向上流动
     
443. //          liushui8();//6色向上流动
     
444. //          liushui8();//6色向上流动
     
445. //          liushui9();//6色向下流动
     
446. //          liushui9();//6色向下流动
     
447. //          liushui9();//6色向下流动
     
448. /******************************************/
     
449. 
     
450.         }
     
451.          
     
452. }
     
453. 
     

复制代码

哇，好厉害好厉害。

谢谢楼主的分享。

厉害 厉害  仿制一个

不错，写的很详细，赞一个。。