标题: DIY单片机五角星流水灯 源程序 [打印本页]

---

作者: lei267915    时间: 2019-12-20 21:12
标题: DIY单片机五角星流水灯 源程序
基于单片机的五角星流水灯DIY，有兴趣的小伙伴可以看看


单片机源程序如下:

1. #include "STC15F2K.h"
   
2. 
   
3. #define uchar unsigned char
   
4. #define uint unsigned int
   
5. 
   
6. sbit D1=P1^2;
   
7. sbit D3=P1^1;
   
8. sbit D5=P1^0;
   
9. sbit D7 =P2^7;
   
10. sbit D9=P2^6;
    
11. sbit D11=P1^7;
    
12. sbit D13=P1^6;
    
13. sbit D15=P1^5;
    
14. sbit D17=P1^4;
    
15. sbit D19=P1^3;
    
16. sbit D21=P3^3;
    
17. sbit D23=P3^2;
    
18. sbit D25=P3^1;
    
19. sbit D27=P3^0;
    
20. sbit D29=P0^1;
    
21. sbit D31=P2^0;
    
22. sbit D33=P3^7;
    
23. sbit D35=P3^6;
    
24. sbit D37=P3^5;
    
25. sbit D39=P3^4;
    
26. sbit D41=P2^1;
    
27. sbit D43=P2^2;
    
28. sbit D45=P2^3;
    
29. sbit D47=P2^4;
    
30. sbit D49=P2^5;
    
31. 
    
32. void Delayms(uint t)
    
33. {
    
34.         uchar i;
    
35.         while(t--)
    
36.            for(i=0;i<123;i++);
    
37. }
    
38. void xg1()
    
39. {
    
40.         P2=0X00;
    
41.         P1=0X00;
    
42.         P3=0X00;
    
43.         D7=0;
    
44.         D29=0;
    
45.         Delayms(9000);
    
46.         Delayms(9000);
    
47.         Delayms(9000);
    
48.         Delayms(9000);
    
49.         Delayms(9000);
    
50. }
    
51. void xg2()
    
52. {
    
53.         char i;
    
54.         for(i=0;i<8;i++)
    
55.         {
    
56.                 D1=D3=D5=D7=D9=D19=D17=D15=D13=D11=D29=D27=D25=0;
    
57.                 D49=D47=D45=D43=D41=D31=D33=D35=D37=D39=D21=D23=1;
    
58.                 Delayms(2000);       
    
59.                 D1=D3=D5=D7=D9=D19=D17=D15=D13=D11=D29=D27=D25=1;
    
60.                 D49=D47=D45=D43=D41=D31=D33=D35=D37=D39=D21=D23=0;
    
61.                 Delayms(2000);       
    
62.         }
    
63. }
    
64. void xg3()
    
65. {
    
66.         char i;
    
67.         for(i=0;i<10;i++)
    
68.         {
    
69.                 P2=0X55;
    
70.                 P1=0X55;
    
71.                 P3=0X55;
    
72.                 D7=0;
    
73.                 Delayms(1000);       
    
74.                 P2=0XAA;
    
75.                 P1=0XAA;
    
76.                 P3=0XAA;
    
77.                 D7=1;
    
78.                 Delayms(1000);       
    
79.         }
    
80. }
    
81. void xg4()
    
82. {
    
83.         char i;
    
84.         bit f;
    
85. 
    
86.         for(i=0;i<3;i++)
    
87.         {
    
88.                 f=!f;
    
89.                 D41=f;
    
90.                 Delayms(1000);
    
91.                 D43=f;
    
92.                 Delayms(1000);
    
93.                 D45=f;
    
94.                 Delayms(1000);
    
95.                 D47=f;
    
96.                 Delayms(1000);
    
97.                 D49=f;
    
98.                 Delayms(1000);
    
99.                 D9=f;
    
100.                 Delayms(1000);
     
101.                 D7=f;
     
102.                 Delayms(1000);
     
103.                 D5=f;
     
104.                 Delayms(1000);
     
105.                 D3=f;
     
106.                 Delayms(1000);
     
107.                 D1=f;
     
108.                 Delayms(1000);
     
109.                 D19=f;
     
110.                 Delayms(1000);
     
111.                 D17=f;
     
112.                 Delayms(1000);
     
113.                 D15=f;
     
114.                 Delayms(1000);
     
115.                 D13=f;
     
116.                 Delayms(1000);
     
117.                 D11=f;
     
118.                 Delayms(1000);
     
119.                 D29=f;       
     
120.                 Delayms(1000);
     
121.                 D27=f;
     
122.                 Delayms(1000);
     
123.                 D25=f;
     
124.                 Delayms(1000);
     
125.                 D23=f;
     
126.                 Delayms(1000);
     
127.                 D21=f;
     
128.                 Delayms(1000);
     
129.                 D39=f;
     
130.                 Delayms(1000);
     
131.                 D37=f;
     
132.                 Delayms(1000);
     
133.                 D35=f;
     
134.                 Delayms(1000);
     
135.                 D33=f;
     
136.                 Delayms(1000);
     
137.                 D31=f;
     
138.                 Delayms(1000);
     
139.         }
     
140.         D29=1;
     
141.         P1=0XFF;
     
142.         P2=0XFF;
     
143.         P3=0XFF;
     
144. }
     
145. void xg5()
     
146. {
     
147.         char i;
     
148.         bit f;
     
149.         int yanshi=9000;
     
150. 
     
151.         for(i=0;i<17;i++)
     
152.         {
     
153.                 f=!f;
     
154.                 D9=f;
     
155.                 D19=f;
     
156.                 D29=f;
     
157.                 D39=f;
     
158.                 D41=f;
     
159.                 Delayms(yanshi);
     
160.                 yanshi=yanshi-500;                                       
     
161.         }
     
162.         D29=1;
     
163.         P1=0XFF;
     
164.         P2=0XFF;
     
165.         P3=0XFF;
     
166. }
     
167. void xg6()//不完善
     
168. {
     
169.         D49=0;
     
170.         D47=0;
     
171.         D9=0;
     
172.         D7=0;
     
173.         Delayms(1000);
     
174. 
     
175.         D49=1;
     
176.         D47=1;
     
177.         D9=1;
     
178.         D7=1;
     
179.         D45=0;
     
180.         D43=0;
     
181.         D5=0;
     
182.         D3=0;
     
183.         Delayms(1000);
     
184. 
     
185.         D45=1;
     
186.         D43=1;
     
187.         D5=1;
     
188.         D3=1;
     
189.         D41=0;
     
190.         D31=0;
     
191.         D1=0;
     
192.         D19=0;
     
193.         Delayms(1000);
     
194. 
     
195.         D41=1;
     
196.         D31=1;
     
197.         D1=1;
     
198.         D19=1;
     
199.         D33=0;
     
200.         D35=0;
     
201.         D17=0;
     
202.         D15=0;
     
203.         Delayms(1000);
     
204. 
     
205.         D33=1;
     
206.         D35=1;
     
207.         D17=1;
     
208.         D15=1;
     
209.         D37=0;
     
210.         D39=0;
     
211.         D13=0;
     
212.         D11=0;
     
213.         Delayms(1000);
     
214. 
     
215.         D37=1;
     
216.         D39=1;
     
217.         D13=1;
     
218.         D11=1;
     
219.         D21=0;
     
220.         D23=0;
     
221.         D29=0;
     
222.         D27=0;
     
223.         D25=0;
     
224.         Delayms(1000);
     
225. 
     
226.         D37=0;
     
227.         D39=0;
     
228.         D13=0;
     
229.         D11=0;
     
230.         D21=1;
     
231.         D23=1;
     
232.         D29=1;
     
233.         D27=1;
     
234.         D25=1;
     
235.         Delayms(1000);
     
236. 
     
237.         D33=0;
     
238.         D35=0;
     
239.         D17=0;
     
240.         D15=0;
     
241.         D37=1;
     
242.         D39=1;
     
243.         D13=1;
     
244.         D11=1;
     
245.         Delayms(1000);
     
246. 
     
247.         D41=0;
     
248.         D31=0;
     
249.         D1=0;
     
250.         D19=0;
     
251.         D33=1;
     
252.         D35=1;
     
253.         D17=1;
     
254.         D15=1;
     
255.         Delayms(1000);
     
256. 
     
257.         D45=0;
     
258.         D43=0;
     
259.         D5=0;
     
260.         D3=0;
     
261.         D41=1;
     
262.         D31=1;
     
263.         D1=1;
     
264.         D19=1;
     
265.         Delayms(1000);
     
266. 
     
267.         D49=0;
     
268.         D47=0;
     
269.         D9=0;
     
270.         D7=0;
     
271.         D45=1;
     
272.         D43=1;
     
273.         D5=1;
     
274.         D3=1;
     
275.         Delayms(1000);
     
276. 
     
277.         D49=1;
     
278.         D47=1;
     
279.         D9=1;
     
280.         D7=1;
     
281.         Delayms(1000);
     
282. 
     
283.         D29=1;
     
284.         P1=0XFF;
     
285.         P2=0XFF;
     
286.         P3=0XFF;
     
287. }
     
288. void xg7()
     
289. {
     
290.         char i;
     
291.         int yanshi=2000;
     
292. 
     
293.         for(i=0;i<6;i++)
     
294.         {
     
295.                 D49=1;
     
296.                 D9=0;
     
297.                 Delayms(yanshi);
     
298.                 D9=1;
     
299.                 D7=0;
     
300.                 Delayms(yanshi);
     
301.                 D7=1;
     
302.                 D5=0;
     
303.                 Delayms(yanshi);
     
304.                 D5=1;
     
305.                 D3=0;
     
306.                 Delayms(yanshi);
     
307.                 D3=1;
     
308.                 D1=0;
     
309.                 Delayms(yanshi);
     
310.                 D1=1;
     
311.                 D19=0;
     
312.                 Delayms(yanshi);
     
313.                 D19=1;
     
314.                 D17=0;
     
315.                 Delayms(yanshi);
     
316.                 D17=1;
     
317.                 D15=0;
     
318.                 Delayms(yanshi);
     
319.                 D15=1;
     
320.                 D13=0;
     
321.                 Delayms(yanshi);
     
322.                 D13=1;
     
323.                 D11=0;
     
324.                 Delayms(yanshi);
     
325.                 D11=1;
     
326.                 D29=0;
     
327.                 Delayms(yanshi);
     
328.                 D29=1;
     
329.                 D27=0;
     
330.                 Delayms(yanshi);
     
331.                 D27=1;
     
332.                 D25=0;
     
333.                 Delayms(yanshi);
     
334.                 D25=1;
     
335.                 D23=0;
     
336.                 Delayms(yanshi);
     
337.                 D23=1;
     
338.                 D21=0;
     
339.                 Delayms(yanshi);
     
340.                 D21=1;
     
341.                 D39=0;
     
342.                 Delayms(yanshi);
     
343.                 D39=1;
     
344.                 D37=0;
     
345.                 Delayms(yanshi);
     
346.                 D37=1;
     
347.                 D35=0;
     
348.                 Delayms(yanshi);
     
349.                 D35=1;
     
350.                 D33=0;
     
351.                 Delayms(yanshi);
     
352.                 D33=1;
     
353.                 D31=0;
     
354.                 Delayms(yanshi);
     
355.                 D31=1;
     
356.                 D41=0;
     
357.                 Delayms(yanshi);
     
358.                 D41=1;
     
359.                 D43=0;
     
360.                 Delayms(yanshi);
     
361.                 D43=1;
     
362.                 D45=0;
     
363.                 Delayms(yanshi);
     
364.                 D45=1;
     
365.                 D47=0;
     
366.                 Delayms(yanshi);
     
367.                 D47=1;
     
368.                 D49=0;
     
369.                 Delayms(yanshi);
     
370.                 yanshi=yanshi-300;
     
371.         }
     
372.         D29=0;
     
373.         P1=0X00;
     
374.         P2=0X00;
     
375.         P3=0X00;
     
376.         Delayms(5000);
     
377.         D29=1;
     
378.         P1=0XFF;
     
379.         P2=0XFF;
     
380.         P3=0XFF;
     
381. }
     
382. void xg8()
     
383. {
     
384.         char i;
     
385.         int yanshi=2200;
     
386.         for(i=0;i<30;i++)
     
387.         {
     
388.                 D9=0;
     
389.                 D19=0;
     
390.                 D29=0;
     
391.                 D39=0;
     
392.                 D41=0;
     
393.                 Delayms(yanshi);
     
394.                
     
395.                 D9=1;
     
396.                 D19=1;
     
397.                 D29=1;
     
398.                 D39=1;
     
399.                 D41=1;
     
400.                 D7=0;
     
401.                 D17=0;
     
402.                 D27=0;
     
403.                 D37=0;
     
404.                 D43=0;
     
405.                 Delayms(yanshi);
     
406.                
     
407.                 D5=0;
     
408.                 D15=0;
     
409.                 D25=0;
     
410.                 D35=0;
     
411.                 D45=0;
     
412.                 D7=1;
     
413.                 D17=1;
     
414.                 D27=1;
     
415.                 D37=1;
     
416.                 D43=1;
     
417.                 Delayms(yanshi);       
     
418.                
     
419.                 D5=1;
     
420.                 D15=1;
     
421.                 D25=1;
     
422.                 D35=1;
     
423.                 D45=1;
     
424.                 D3=0;
     
425.                 D13=0;
     
426.                 D23=0;
     
427.                 D33=0;
     
428.                 D47=0;
     
429.                 Delayms(yanshi);
     
430.                
     
431.                 D1=0;
     
432.                 D11=0;
     
433.                 D21=0;
     
434.                 D31=0;
     
435.                 D49=0;
     
436.                 D3=1;
     
437.                 D13=1;
     
438.                 D23=1;
     
439.                 D33=1;
     
440.                 D47=1;
     
441.                 Delayms(yanshi);
     
442.                 D1=1;
     
443.                 D11=1;
     
444.                 D21=1;
     
445.                 D31=1;
     
446.                 D49=1;
     
447.                 if(yanshi<200);
     
448.                 else yanshi=yanshi-100;                                                                               
     
449.         }
     
450.         D29=1;
     
451.         P1=0XFF;
     
452.         P2=0XFF;
     
453.         P3=0XFF;       
     
454. }
     
455. void xg9()
     
456. {
     
457.         char i;
     
458.         for(i=0;i<2;i++)
     
459.         {
     
460.                 D49=0;
     
461.                 Delayms(1000);
     
462.                 D9=0;
     
463.                 Delayms(1000);       
     
464.                 D7=0;
     
465.                 Delayms(1000);
     
466.                 D5=0;
     
467.                 Delayms(1000);
     
468.                 D3=0;
     
469.                 Delayms(1000);       
     
470.                 D1=0;
     
471.                 Delayms(1000);
     
472.                 D19=0;
     
473.                 Delayms(1000);       
     
474.                 D17=0;
     
475.                 Delayms(1000);
     
476.                 D15=0;
     
477.                 Delayms(1000);       
     
478.                 D13=0;
     
479.                 Delayms(1000);
     
480.                 D11=0;
     
481.                 Delayms(1000);       
     
482.                 D29=0;
     
483.                 Delayms(1000);
     
484.                 D27=0;
     
485.                 Delayms(1000);
     
486.                 D25=0;
     
487.                 Delayms(1000);       
     
488.                 D23=0;
     
489.                 Delayms(1000);       
     
490.                 D21=0;
     
491.                 Delayms(1000);       
     
492.                 D39=0;
     
493.                 Delayms(1000);       
     
494.                 D37=0;
     
495.                 Delayms(1000);
     
496.                 D35=0;
     
497.                 Delayms(1000);       
     
498.                 D33=0;
     
499.                 Delayms(1000);       
     
500.                 D31=0;
     
501.                 Delayms(1000);       
     
502.                 D41=0;
     
503.                 Delayms(1000);       
     
504.                 D43=0;
     
505.                 Delayms(1000);       
     
506.                 D45=0;
     
507.                 Delayms(1000);       
     
508.                 D47=0;
     
509.                 Delayms(1000);       
     
510. 
     
511.                 D47=1;
     
512.                 Delayms(1000);       
     
513.                 D45=1;
     
514.                 Delayms(1000);       
     
515.                 Delayms(1000);       
     
516.                 D43=1;
     
517.                 Delayms(1000);       
     
518.                 D41=1;
     
519.                 Delayms(1000);       
     
520.                 D31=1;
     
521.                 Delayms(1000);       
     
522.                 D33=1;
     
523.                 Delayms(1000);
     
524.                 D35=1;
     
525.                 Delayms(1000);       
     
526.                 D37=1;
     
527.                 Delayms(1000);       
     
528.                 D39=1;
     
529.                 Delayms(1000);       
     
530.                 D21=1;
     
531.                 Delayms(1000);       
     
532.                 D23=1;
     
533.                 Delayms(1000);
     
534.                 D25=1;
     
535.                 Delayms(1000);
     
536.                 D27=1;
     
537.                 Delayms(1000);       
     
538.                 D29=1;
     
539.                 Delayms(1000);
     
540.                 D11=1;
     
541.                 Delayms(1000);       
     
542.                 D13=1;
     
543.                 Delayms(1000);
     
544.                 D15=1;
     
545.                 Delayms(1000);       
     
546.                 D17=1;
     
547.                 Delayms(1000);
     
548.                 D19=1;
     
549.                 Delayms(1000);       
     
550.                 D1=1;
     
551.                 Delayms(1000);
     
552.                 D3=1;
     
553.                 Delayms(1000);
     
554.                 D5=1;
     
555.                 Delayms(1000);       
     
556.                 D7=1;
     
557.                 Delayms(1000);
     
558.                 D9=1;
     
559.                 Delayms(1000);
     
560.                 D49=1;
     
561.                 Delayms(1000);
     
562.         }                                                               
     
563. }
     
564. void main()
     
565. {
     
566.         D29=1;
     
567.         P1=0XFF;
     
568.         P2=0XFF;
     
569.         P3=0XFF;
     
570.         while(1)
     
571.         {
     
572.                 xg1();
     
573.                 xg2();
     
574.                 xg3();
     
575.                 xg4();
     
576.                 xg5();
     
577.                 xg6();
     
578.                 xg7();
     
579.                 xg8();
     
580.                 xg9();
     
581.         }
     
582. }
     

复制代码

所有资料51hei提供下载:
程序.rar (1.69 MB, 下载次数: 22)

2019-12-20 21:11 上传

点击文件名下载附件
下载积分: 黑币 -5

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1