标题: 单片机心形流水灯制作PCB图与电路原理图及源码 [打印本页]

---

作者: ck123456    时间: 2018-5-5 21:03
标题: 单片机心形流水灯制作PCB图与电路原理图及源码
Altium Designer画的心形流水灯原理图和PCB图如下：(51hei附件中可下载工程文件)


单片机源程序如下:

1. #include <reg52.h>      
   
2. #include<intrins.h>                  //包含_crol_函数的头文件
   
3. #define uchar unsigned char
   
4. #define uint   unsigned int
   
5. 
   
6. 
   
7. uchar  aa,bb,cc,dd,ee;
   
8. void  delayms(uint t);
   
9. void  a();  
   
10. void  b();
    
11. void  c();
    
12. void  d();
    
13. void  e();
    
14. void  f();
    
15. void  g();
    
16. void  h();
    
17. void k();
    
18. void q();
    
19. void p();
    
20. void l();
    
21. void x();
    
22. void v();
    
23. void z();
    
24. void y();
    
25. void w();
    
26. void m();
    
27. void r();
    
28. void i();
    
29. 
    
30. 
    
31. uchar code  LP0[]={0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f,0xff,
    
32.                                    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,//半个心向下
    
33. 
    
34.                                    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    
35.                                    0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff,//半心向上
    
36. 
    
37.                                    0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f,0xff,
    
38.                                    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
    
39.                                    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
    
40.                                    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,//从右到左全心
    
41. 
    
42. 
    
43. 
    
44.                                   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    
45.                                   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    
46.                                   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    
47.                                   0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff//从左到全心
    
48.                   
    
49.                                    };
    
50. uchar code  LP1[]={0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f,0xff,
    
51.                                    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,//
    
52. 
    
53.                                         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    
54.                                         0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff,//
    
55. 
    
56.                                    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    
57.                                    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    
58.                                    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    
59.                                    0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff,//
    
60. 
    
61. 
    
62. 
    
63. 
    
64.                                    0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f,0xff,
    
65.                                    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
    
66.                                    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
    
67.                                    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
    
68. 
    
69.                   
    
70.                                    };
    
71. uchar code  LP3[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    
72.                    0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f,0xff,//
    
73. 
    
74.                                    0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff,
    
75.                                    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff ,//
    
76. 
    
77.                                    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    
78.                                    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    
79.                                   0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff,
    
80.                                   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff ,//
    
81. 
    
82. 
    
83. 
    
84. 
    
85.                                   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    
86.                                   0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f,0xff,
    
87.                                   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff ,
    
88.                                   0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
    
89. 
    
90.                                    
    
91.                   
    
92.                                    };
    
93. 
    
94. uchar code  LP2[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    
95.                                    0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff,//
    
96. 
    
97.                                    0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f,0xff,
    
98.                                    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff ,//
    
99. 
    
100.                                    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
     
101.                                    0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff,
     
102.                                    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
     
103.                                    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,//
     
104. 
     
105. 
     
106. 
     
107.                                    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
     
108.                                    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
     
109.                                    0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f,0xff,
     
110.                                    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
     
111.                   
     
112.                                    };
     
113. uchar code  LP01[]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80//从0到7的一个一个亮
     
114.                                    
     
115. 
     
116. };
     
117. 
     
118. uchar code  LP02[]={0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01};//从7到0的一个一个亮
     
119.   
     
120.   
     
121. uchar code  LP03[]={
     
122.              0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff
     
123.                                   };
     
124. 
     
125. 
     
126. uchar code  LP04[]={
     
127.              0xff,0x7f,0x3f,0x1f,0x0f,0x07,0x03,0x01,0x00
     
128.                                   };//从7开始逐个灭
     
129. uchar code  LP05[]={0xff,0xfe,0xfc,0xf8,0xf0,0xe0,0xc0,0x80,0x00
     
130.                        };//从0开始到7逐个灭
     
131.   uchar code  LP06[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
     
132.                     };
     
133. 
     
134. uchar code  LP07[]={0x00,0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff
     
135.              };//从7逐个亮
     
136. uchar code  LP08[]={0x00,0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f,0xff
     
137.                }; //从0开始逐个亮
     
138. 
     
139.   void main()
     
140. {         
     
141.           k();q();p();v();v();l();l();w();h();h();h();k();m();e();p();c();c();c();c();
     
142.           r();d();d();h();h();l();p();d();
     
143.           d();y();i();p();v();l();k();h();g();
     
144.           f();d();k();p();h();h();z();x();c();v();b();m();
     
145.           z();q();f();k();v();v();w();r(); d();d();x();y();i();l();k();h();
     
146.          c();v();p();g();k();l();l();b();m();k(); g();        p();
     
147.    v();e();y();p();i();p();p();k();g();f(); w();
     
148.           z();l();x();c();c();c();c();c();k();p();e();q();v();v();r();b();m();h();
     
149.          m();h();d();w();r();k();k();g();k();k();k();x();
     
150.          k();d();d();y();l();z();k();j();g();  
     
151.           f();p();c();c();c();c();i();v();p();k();k();p();k();b(); a();q();
     
152. }                                                                                       
     
153. 
     
154. 
     
155. 
     
156. 
     
157. 
     
158. void a() //顺时针一个流水
     
159. {
     
160. uint i,m=150;
     
161. for(m;m>80;m=m-8)
     
162.          {
     
163.          for(i=0;i<8;i++)
     
164.                 {
     
165.                 P1=P2=P3=0X00;
     
166.                  P0=LP01[i];
     
167.                  delayms(m);
     
168. 
     
169.                 }  
     
170.                 for(i=0;i<8;i++)
     
171.                 {
     
172.                 P0=P1=P3=0X00;
     
173.                  P2=LP02[i];
     
174.                  delayms(m);
     
175.                 }   
     
176.                
     
177.             for(i=0;i<8;i++)
     
178.                 {
     
179.                 P1=P2=P0=0X00;
     
180.                  P3=LP02[i]        ;
     
181.                  delayms(m);
     
182.                 }
     
183. 
     
184.             for(i=0;i<8;i++)
     
185.                 {
     
186.                 P0=P2=P3=0X00;
     
187.                  P1=LP02[i];
     
188.           delayms(m);
     
189.                   
     
190.                 }
     
191.                 }
     
192.         }                  
     
193. 
     
194.         void b()
     
195.         {                uint i;
     
196.                                      for(i=0;i<97;i++)        
     
197.                                                  {                                                
     
198.                                            uint m=150;
     
199.                                                    P0=LP0[i];
     
200.                                                    P1=LP1[i];
     
201.                                                    P2=LP2[i];
     
202.                                                    P3=LP3[i];
     
203.                                                    delayms(m);                                                
     
204.                                                    }
     
205. 
     
206. 
     
207.           }
     
208. 
     
209. 
     
210. 
     
211. 
     
212.           void c() //一起闪灭
     
213.    {
     
214.            uint m=380;
     
215.         for(m;m>30;m=m-50)
     
216.         {P0=P1=P2=P3=0X00;
     
217.         delayms(m);        
     
218.         P0=P1=P2=P3=0xff;
     
219.     delayms(m);
     
220.         
     
221.         }
     
222. 
     
223. 
     
224.           }
     
225. 
     
226. void d()          //8灯顺时针行走
     
227. {         uint m=140,j=0,i=0,k=0,q=0;
     
228. 
     
229.            for(j;j<9;j++)         //从0到2过度
     
230. {   
     
231. P0=LP05[j];
     
232.         P2=LP07[j];
     
233.         P1=P3=LP06[j];
     
234.         delayms(m);
     
235.       }
     
236.          
     
237.   
     
238.          
     
239.                   for(i;i<9;i++) //从2到3过度
     
240. {  
     
241. P0=P1=LP06[i];
     
242.         P2=LP04[i];
     
243.     P3=LP07[i];
     
244.         delayms(m);
     
245. 
     
246.       }
     
247. 
     
248. 
     
249. 
     
250.                   for(k;j<9;k++)//从3到1过度
     
251. {  
     
252. P0=P2=LP06[k];
     
253.         P3=LP04[k];
     
254. P1=LP07[k];
     
255.         delayms(m);
     
256. 
     
257.       }
     
258.            
     
259.                   for(q;q<9;q++)//从3到0过度
     
260. {
     
261. P3=P2=LP06[q];
     
262.         P1=LP04[q];
     
263. P0=LP08[q];
     
264.         delayms(m);
     
265. 
     
266.       }
     
267. 
     
268. }         
     
269. 
     
270.         void e() //单个从俩边向中间
     
271.         {   uint i,j,m=250;
     
272.          for(i=0;i<8;i++)
     
273.          {
     
274.          P0=P1=LP01[i];
     
275.         P2=P3=LP06[i];
     
276.         delayms(m);
     
277.         for(j=0;j<8;j++)
     
278.          {
     
279.          P3=LP01[j];
     
280.          P2=LP02[j];
     
281.         P0=P1=LP06[j];
     
282.         delayms(m);
     
283.          }
     
284.         }
     
285.         }
     
286.         void f()//从中间一个向两边
     
287.         { uint i,m=200;
     
288.           for(i=0;i<8;i++)
     
289.          {
     
290.          P0=P2=P1=LP02[i];
     
291.         P3=LP01[i];
     
292.         delayms(m);
     
293.         }
     
294.         
     
295.         
     
296.         }
     
297. 
     
298. 
     
299.         void g()//中间向俩边亮着走向俩边收回
     
300. {  uint i,j,m=200;
     
301.   for(i=0;i<8;i++)
     
302.          {
     
303.          P0=P2=P1=LP07[i];
     
304.         P3=LP08[i];
     
305.         delayms(m);
     
306.         }
     
307.         for(j=0;j<9;j++)
     
308.          {
     
309.          P0=P2=P1=LP04[j];
     
310.         P3=LP05[j];
     
311.         delayms(m);
     
312.         }
     
313. }
     
314. 
     
315.         void h()//从中间亮再从下面回来
     
316. {  uint i,j,m,n;
     
317.   for(i=0;i<8;i++)
     
318.          {m=200;
     
319.          P0=P2=P1=LP07[i];
     
320.         P3=LP08[i];
     
321.         delayms(m);
     
322.         }
     
323.         for(n=0;n<5;n++)
     
324.          {  m=200;
     
325.           P0=P2=P1=P3=0xff;
     
326.           delayms(m);
     
327.         }
     
328.         for(j=0;j<9;j++)
     
329.          { m=200;
     
330.          P0=P2=P1=LP08[j];
     
331.         P3=LP07[j];
     
332.         delayms(m);
     
333.         }
     
334.         
     
335.         for(n=0;n<5;n++)
     
336.          {  m=200;
     
337.           P0=P2=P1=P3=0xff;
     
338.           delayms(m);
     
339.         }
     
340.          
     
341.         }
     
342.                 void k() //乱花闪
     
343.         {   uint i,m=100;
     
344.          for(i=0;i<8;i++)
     
345.          {
     
346.          P0=P1=P2=P3=0xaa;
     
347.          delayms(m);
     
348.         P0=P1=P2=P3=0x55;
     
349.         delayms(m);
     
350.                                                                   
     
351.          }
     
352. 
     
353.          }
     
354. 
     
355. 
     
356. 
     
357.          void q() //逆时针一个流水
     
358. {
     
359. uint i,m=180;
     
360. for(m;m>0;m=m-10)
     
361.          {
     
362.         
     
363.                 for(i=0;i<8;i++)
     
364.                 {
     
365.                 P0=P2=P3=0X00;
     
366.                  P1=LP01[i];
     
367.           delayms(m);
     
368.                   
     
369.                 }
     
370.         
     
371.             for(i=0;i<8;i++)
     
372.                 {
     
373.                 P1=P2=P0=0X00;
     
374.                 P3=LP01[i]
     
375.                         ;
     
376.                  delayms(m);
     
377.                 }
     
378.                         for(i=0;i<8;i++)
     
379.                 {
     
380.                 P0=P1=P3=0X00;
     
381.                  P2=LP01[i];
     
382.                  delayms(m);
     
383.                 }   
     
384.                
     
385. 
     
386.    
     
387.                  for(i=0;i<8;i++)
     
388.                 {
     
389.                 P1=P2=P3=0X00;
     
390.                  P0=LP02[i];
     
391.                  delayms(m);
     
392. 
     
393.                 }  
     
394.                 }
     
395.         }
     
396. 
     
397. 
     
398. 
     
399.          void p()//先左边亮在右边亮
     
400. {
     
401.    uint i,j,k,o,m=160;
     
402. 
     
403.     for(i=0;i<8;i++)
     
404.                 {
     
405.                 P0=P2=P3=0X00;
     
406.                  P1=LP08[i];
     
407.                  delayms(m);
     
408. 
     
409.                 }  
     
410.                 for(j=0;j<8;j++)
     
411.                 {
     
412.                 P0=P2=0X00;
     
413.                  P3=LP08[j];
     
414.                  delayms(m);
     
415. 
     
416.                 }
     
417.                 for(k=0;k<8;k++)
     
418.                 {
     
419.                 P1=P3=0Xff;
     
420.                  P0=LP08[k];
     
421.                  delayms(m);
     
422. 
     
423.                 }
     
424.                 for(o=0;o<8;o++)
     
425.                 {
     
426.                 P1=P3=P0=0Xff;
     
427.                  P2=LP07[o];
     
428.                  delayms(m);
     
429. 
     
430.                 }   
     
431. }
     
432. 
     
433. 
     
434.     void l() //先从左一半灭全灭完后在右边
     
435.         {
     
436.          uint i,j,x,s,m=300;
     
437.                 P1=P3=P0=0Xff;
     
438.                 delayms(80);
     
439.                 for(i=0;i<8;i++)
     
440.                 {
     
441.                 P1=P3=P0=0Xff;
     
442.                  P2=LP05[i];
     
443.                  delayms(m);
     
444.                    }
     
445.                 for(j=0;j<8;j++)
     
446.                 {
     
447.                 P1=P3=0Xff;
     
448.                 P2=0x00;
     
449.                  P0=LP04[j];
     
450.                  delayms(m);
     
451. 
     
452.                 }
     
453.                         for(x=0;x<8;x++)
     
454.                 {
     
455.                 P0=P2=0x00;
     
456.                 P1=0xff;
     
457. 
     
458.                  P3=LP04[x];
     
459.                  delayms(m);
     
460. 
     
461.                 }
     
462.                
     
463.                         for(s=0;s<8;s++)
     
464.                 {
     
465.                 P0=P2=P3=0x00;
     
466.                
     
467. 
     
468.                  P1=LP04[s];
     
469.                  delayms(m);
     
470. 
     
471.                 }     
     
472.         
     
473.         }
     
474. 
     
475. 
     
476.         void x()//逆时针流水
     
477.         {
     
478.          uint i,j,k,n;
     
479.                  for(i=0;i<8;i++)
     
480.                 {
     
481.                 P0=P2=P3=0x00;
     
482.                
     
483. 
     
484.                  P1=LP01[i];
     
485.                  delayms(250);
     
486. 
     
487.                 }     
     
488.                            for(j=0;j<8;j++)
     
489.                 {
     
490.                 P0=P2=P1=0x00;
     
491.                
     
492. 
     
493.                  P3=LP01[j];
     
494.                  delayms(200);
     
495. 
     
496.                 }   
     
497.                         for(k=0;k<8;k++)
     
498.                 {
     
499.                 P0=P3=P1=0x00;
     
500.                
     
501. 
     
502.                  P2=LP01[k];
     
503.                  delayms(170);
     
504. 
     
505.                 }
     
506.                         for(n=0;n<8;n++)
     
507.                 {
     
508.                 P2=P3=P1=0x00;
     
509.                
     
510. 
     
511.                  P0=LP02[n];
     
512.                  delayms(130);
     
513. 
     
514.                 }   
     
515.         
     
516.         
     
517.         }
     
518. 
     
519. 
     
520. 
     
521. 
     
522. 
     
523. 
     
524.          void v()//中间向俩边
     
525.          {
     
526.            uint i,j,k,n,p,m;
     
527. 
     
528.     for(i=0;i<8;i++)
     
529.                 { m=300;
     
530.         P0=P2=P3=P1=0X00;
     
531.                  P3=LP08[i];
     
532.                  delayms(m);
     
533. 
     
534.                 }  
     
535.                 for(j=0;j<8;j++)
     
536.                 { m=300;
     
537.                 P0=P1=0X00;
     
538.                 P3=0xff;
     
539.                  P2=LP07[j];
     
540.                  delayms(m);
     
541. 
     
542.                 }  
     
543.                    for(k=0;k<8;k++)
     
544.                 {  m=300;
     
545.                 P3=P2=0Xff;
     
546.                 P0=0x00;
     
547.                  P1=LP07[k];
     
548.                  delayms(m);
     
549. 
     
550.                 }
     
551.                 for(n=0;n<8;n++)
     
552.                 {  m=300;
     
553.         P1=P3=P2=0Xff;
     
554.         P0=0x00;
     
555.                  P0=LP07[n];
     
556.                  delayms(m);
     
557. 
     
558.                 }
     
559.                                 for(p=0;p<3;p++)
     
560.                 {   m=80;
     
561. P0=P1=P3=P2=0Xff;
     
562.                  delayms(m);
     
563.    
     
564.    }
     
565.          
     
566.          
     
567.          
     
568.          }
     
569.    void z()//对角开始亮
     
570.    {
     
571.             uint i,j,k,m;
     
572.            for(i=0;i<8;i++)
     
573.                 {
     
574.                   m=200;
     
575.                  P0=LP08[i];
     
576.                  P3=LP07[i];
     
577.                  P1=P2=0x00;
     
578.                  delayms(m);
     
579. 
     
580.                 }
     
581.    
     
582.                         for(j=0;i<j;j++)
     
583.                 {
     
584.                     m=200;
     
585.                  P2=P1=LP08[j];
     
586.         
     
587.                  P3=P0=0xff;
     
588.                  delayms(m);
     
589. 
     
590.                 }
     
591.                 for(k=0;k<3;k++)
     
592.                 {   m=40;
     
593. P0=P1=P3=P2=0Xff;
     
594.                  delayms(m);
     
595.    
     
596.    }
     
597. 
     
598. }         
     
599. 
     
600. void y() //从左边向俩边灭
     
601. {uint i,j,k,m;
     
602. 
     
603. 
     
604. for(i=0;i<8;i++)
     
605.                 {   m=200;
     
606. P1=LP04[i];
     
607. P3=        LP05[i];
     
608. P0=P2=0xff;
     
609. 
     
610.                  delayms(m);
     
611.    
     
612.    }
     
613. for(j=0;j<8;j++)
     
614.                 {   m=200;
     
615. P2=P0=LP05[j];
     
616. 
     
617. P1=P3=0x00;
     
618. 
     
619.                  delayms(m);
     
620.    
     
621.    }
     
622. 
     
623. for(k=0;k<3;k++)
     
624.                 {   m=160;
     
625. P0=P1=P3=P2=0Xff;
     
626.                  delayms(m);
     
627.    
     
628.    }
     
629. }
     
630.         
     
631.            void i()
     
632.    {
     
633.    uint n,j,m=200;
     
634.   for(m=200;m>20;m=m-15)
     
635.   
     
636.   {
     
637.    for(n=0;n<8;n++)
     
638.                 {  
     
639.   P0=LP08[n];
     
640.      P3=LP07[n];
     
641.     P1=P2=0x00;
     
642.                  delayms(m);
     
643.    
     
644.       }
     
645.             for(j=0;j<8;j++)
     
646.                 {   
     
647. 
     
648.      P1=P2=LP07[j];
     
649.       P0=P3=0xff;
     
650.          delayms(m);
     
651.    
     
652.    }
     
653.    
     
654.    }
     
655. 
     
656. }         
     
657.      void w()//半个反向像一起
     
658.    {
     
659.    uint n,j,m=200;
     
660.   for(m=200;m>20;m=m-15)
     
661.   
     
662.   {
     
663.    for(n=0;n<8;n++)
     
664.                 {  
     
665.   P0=LP08[n];
     
666.      P3=LP07[n];
     
667.     P1=P2=0x00;
     
668.                  delayms(m);
     
669.    
     
670.       }
     
671.             for(j=0;j<8;j++)
     
672.                 {   
     
673. 
     
674.      P1=P2=LP07[j];
     
675.       P0=P3=0xff;
     
676.          delayms(m);
     
677.              }
     
678. 
     
679.    }
     
680. 
     
681. }         
     
682. 
     
683.          void m() //一半反着走
     
684.    {
     
685.    uint i,n,j,m=200;
     
686.   for(m=100;m>20;m=m-15)
     
687.   
     
688.   {
     
689.    for(n=0;n<8;n++)
     
690.                 {  
     
691.   P1=P2=LP08[n];
     
692.      
     
693.     P0=P3=0x00;
     
694.                  delayms(m);
     
695.    
     
696.       }
     
697.             for(j=0;j<8;j++)
     
698.                 {   
     
699. 
     
700.      P3=P0=LP08[j];
     
701.          P0=LP07[j];
     
702.       P1=P2=0xff;
     
703.          delayms(m);
     
704.              }
     
705.          
     
706.    }
     
707.    for(i=0;i<3;i++)
     
708.                 {   
     
709.                  m=150;
     
710.   
     
711.       P3=P0=P1=P2=0xff;
     
712.          delayms(m);
     
713.              }
     
714. 
     
715. }
     
716. void r()
     
717.   {uint m;
     
718.          
     
719.    for(m=400;m>10;m=m-10)   
     
720.                
     
721.           {
     
722.       P3=P1=0xff;
     
723.            P0=P2=0x00;
     
724.                    delayms(m);
     
725.           P3=P1=0x00;
     
726.            P0=P2=0xff;
     
727.              delayms(m);
     
728.            }
     
729.   }
     
730.          
     
731. 
     
732.                         
     
733.      void delayms(uint t)   //毫秒延时
     
734. {
     
735.          uint i,j;
     
736.         for(i=t;i>0;i--)
     
737.          for(j=110;j>0;j--);        
     
738. 
     
739. }
     
740.                                     
     

复制代码

所有资料51hei提供下载:
心形流水灯制作.rar (662.86 KB, 下载次数: 106)

2018-5-6 01:27 上传

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

---

作者: 泡泡1    时间: 2018-6-23 20:14
做出来不对啊

---

作者: ck123456    时间: 2019-2-18 14:18

泡泡1 发表于 2018-6-23 20:14
做出来不对啊

可以的

---

作者: 焱淼    时间: 2019-3-7 20:06
谢谢楼主  很有用呢

---

作者: 焱淼    时间: 2019-3-7 20:28
请问楼主电阻都是多少Ω的呢？ 原理图中D20和D21之间的那个LED灯是什么呢  多的吗？

---

作者: ck123456    时间: 2019-3-9 14:48

焱淼 发表于 2019-3-7 20:28
请问楼主电阻都是多少Ω的呢？ 原理图中D20和D21之间的那个LED灯是什么呢  多的吗？

不好意哈，多了忘记删

---

作者: ck123456    时间: 2019-3-9 14:49

焱淼 发表于 2019-3-7 20:28
请问楼主电阻都是多少Ω的呢？ 原理图中D20和D21之间的那个LED灯是什么呢  多的吗？

电阻我用1k

---

作者: liuzhibiao    时间: 2019-3-11 16:22
截图里两条线没连

---

作者: 王成成    时间: 2019-8-31 21:14
灯是不是多了

---

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

Powered by Discuz! X3.1