标题: 单片机舞台灯程序 含有源码 我一直收藏的 [打印本页]

---

作者: 人在江湖    时间: 2017-4-20 20:01
标题: 单片机舞台灯程序 含有源码 我一直收藏的
我收藏的舞台灯程序 含有源码

完整源码下载（包含头文件内容）：
舞台灯程序.docx (18.5 KB, 下载次数: 28)

2017-4-20 19:59 上传

点击文件名下载附件
舞台灯程序
下载积分: 黑币 -5

单片机源码：

1. #include<reg52.h>
   
2. #include<intrins.h>
   
3. #include"led_disp.h"
   
4. /********引脚定义*******/        
   
5. sbit  led1=P1^2;                    //蓝灯
   
6. sbit  led2=P1^3;                                        //绿灯
   
7. sbit  led3=P1^4;                                        //红灯
   
8. /*********89板测试引脚***************
   
9. sbit  key4=P3^3;                 //存储
   
10. sbit  key3=P3^2;                //减
    
11. sbit  key2=P3^1;           //T0          加
    
12. sbit  key1=P3^0;           //T1  模式选择
    
13. */
    
14. 
    
15. // 彩灯引脚
    
16. sbit  key4=P1^6;                 //存储
    
17. sbit  key3=P1^7;                //减
    
18. sbit  key2=P3^4;           //T0          加
    
19. sbit  key1=P3^5;           //T1  模式选择
    
20. //-----------------------------------------//
    
21. sbit voice=P1^0;         //声控引脚
    
22. 
    
23. /***********延时函数*******************/                                       
    
24. void delay(unsigned int time);
    
25. void delayus(uint t);
    
26. void delayms(uint k);
    
27. 
    
28. void delay_nms(uint n);        
    
29. void delay_1ms(void);         
    
30. /****模式设置函数***************************/
    
31. void led_1(uint t);
    
32. void led_2(uint t);
    
33. void led_3(uint t);
    
34. 
    
35. void led_mod0(void);
    
36. void led_mod1(void);           // 模式1
    
37. void led_mod2(void);           //模式2
    
38. void led_mod3(void);           //模式3
    
39. void led_mod4(void);           //模式4,声控模式
    
40. 
    
41. /********按键功能函数*********************/
    
42. void key1_fun(void);
    
43. void key2_fun(void);
    
44. void key3_fun(void);
    
45. void key4_fun(void);
    
46. void key_fun(void);
    
47. /*********中断、显示、其他函数***********/
    
48. void  InitTimer0(void);                //定时100us,用于数码管显示；中断用于执行数码管显示
    
49. void  InitTimer1(void);                //定时10ms，用于按键；中断执行按键扫描
    
50. void disp(void);
    
51. void dis(void);
    
52. void dis1(void);
    
53. 
    
54. /******************************/
    
55. void led_work(void);    //led 花样闪烁
    
56. void led_rem(void);                   //记忆模式功能，开机时执行
    
57. void voice_ctr(void);        //声控功能
    
58. 
    
59.                                           
    
60. uint MOD_T;                        //模式闪烁快慢变量
    
61. uchar MOD_NUM,MOD_T_ADD;                //模式号，模式闪烁时间快慢变量
    
62. /**********模式闪烁快慢变量及对应的向量**************************************/
    
63. uint MOD_T0,MOD_T1,MOD_T2,MOD_T3,MOD_T4,MOD_T5;
    
64. uchar MOD_T_ADD0,MOD_T_ADD1,MOD_T_ADD2,MOD_T_ADD3,MOD_T_ADD4,MOD_T_ADD5;
    
65. uint MOD_TR[6];                   //         元素7为存储变量
    
66. uchar MOD_T_ADDR[6];        //
    
67. /********存储记忆变量*****************/
    
68. uchar MOD_NUM_REM;
    
69. uchar MOD_T_ADD_REM;
    
70. uint num;        //声控变量
    
71. /****************************************************************************/
    
72. uint delay_time;             //MOD_T=3000-55*（MOD_T_ADD+1）;           200--60000
    
73. uchar t,TN; //定时器0变量
    
74. bit key_flag;
    
75. 
    
76. //code uchar led_mod[]={0x39,0x39,0x39,0x73,0x39,0x6d,0x5e,0x79,0x7c,0x79,0x5e,0x3f};          //89板模式数显段
    
77. 
    
78. //code uchar  led_tab[]={0x0A,0xFA,0x8C,0x98,0x78,0x19,0x09,0xBA,0x08,0x18,   0x49,0x0F,0xC8,0x0D,0x2C};          //0-9,b,c,d,e,p
    
79. code uchar led_mod[]={0x0f,0x0f,0x0f,0x2c,0x0f,0x19,0xc8,0x0d,0x49,0x0d,0xc8,0x0a};    //彩灯模式数显段
    
80. //主函数                                
    
81. void main(void)
    
82. {
    
83.     InitTimer0();
    
84.         InitTimer1();
    
85. 
    
86.         led1=0;
    
87.         led2=0;
    
88.         led3=0;
    
89.         P2=0x00;        //数码管初始化控制
    
90. 
    
91.         MOD_T=6000;                //led闪烁时间变量
    
92.         MOD_TR[0]=6000;
    
93.         MOD_TR[1]=6000;        
    
94.         MOD_TR[2]=6000;        
    
95.         MOD_TR[3]=6000;        
    
96.         MOD_TR[4]=6000;        
    
97.         MOD_TR[5]=6000;        
    
98. 
    
99. 
    
100.         MOD_T_ADDR[0]=0;
     
101.         MOD_T_ADDR[1]=0;
     
102.         MOD_T_ADDR[2]=0;
     
103.         MOD_T_ADDR[3]=0;
     
104.         MOD_T_ADDR[4]=0;
     
105.         MOD_T_ADDR[5]=0;
     
106. 
     
107. 
     
108.         //MOD_NUM=MOD_NUM_REM;
     
109.         //MOD_T_ADD=0;
     
110.     //led_rem();
     
111.         //key_flag=0;
     
112.         while(1)                        //主程序循环         
     
113.         {
     
114.            //led_mod3();
     
115.          
     
116.           // key1_fun();
     
117.            //key2_fun();
     
118.            //key3_fun();
     
119.            //key4_fun();
     
120.            //key_fun();
     
121.            led_work();
     
122.          
     
123.         }
     
124. }
     
125. 
     
126. 
     
127. //延时子函数
     
128. //参数范围 0-65536
     
129. void delayus(uint t)
     
130. {
     
131. while(t--);
     
132. }
     
133.                                         //延时子函时，
     
134.                                         //参数 d_time 控制延时的时间                                                         
     
135.                                         //作用，灯亮和熄灭必须持续一定时间，人眼才能看到
     
136. void delayms(uint k)
     
137. {
     
138.          uint i,j;
     
139.         for(i=0;i<k;i++)
     
140.          for(j=0;j<120;j++);
     
141. }
     
142. 
     
143. void delay_1ms(void)
     
144. {
     
145.    unsigned char a,b;
     
146.     for(b=4;b>0;b--)
     
147.         for(a=248;a>0;a--);
     
148. }
     
149. void delay_nms(uint n)                                   
     
150.   {
     
151.    uint i;
     
152.     for(i=0;i<n;i++)
     
153.          {delay_1ms();}
     
154.   }
     
155.   
     
156. /************************************/
     
157. 
     
158. void led_1(uint t)
     
159. {
     
160.           led1=1;
     
161.           delayms(t);  
     
162.           led1=0;
     
163.           delayms(t);  
     
164.          
     
165. 
     
166.           led2=1;
     
167.           delayms(t);  
     
168.           led2=0;
     
169.           delayms(t);  
     
170. 
     
171.           led3=1;
     
172.           delayms(t);
     
173.           led3=0;
     
174.           delayms(t);
     
175. }
     
176. 
     
177. void led_2(uint t)
     
178. {
     
179.           led1=1;
     
180.           led2=1;
     
181.           delayms(t);
     
182.           led1=0;
     
183.           led2=0;
     
184.           delayms(t);  
     
185.          
     
186. 
     
187.           led2=1;
     
188.           led3=1;
     
189.           delayms(t);  
     
190.           led2=0;
     
191.           led3=0;
     
192.           delayms(t);
     
193. 
     
194.           led3=1;
     
195.           led1=1;
     
196.           delayms(t);
     
197.           led3=0;
     
198.           led1=0;
     
199.           delayms(t);  
     
200. 
     
201. }
     
202. 
     
203. void led_3(uint t)
     
204. {
     
205.           led1=1;
     
206.           led2=1;
     
207.           led3=1;
     
208.           delayms(t);  
     
209.           led1=0;
     
210.           led2=0;
     
211.           led3=0;
     
212.           delayms(t);
     
213. }
     
214. void led_mod0(void)
     
215. {
     
216. led_1(MOD_TR[0]);
     
217. }
     
218. 
     
219. void led_mod1(void)
     
220. {
     
221. led_2(MOD_TR[1]);
     
222. }
     
223. 
     
224. void led_mod2(void)
     
225. {
     
226. led_3(MOD_TR[2]);
     
227. }
     
228. 
     
229. void led_mod3(void)
     
230. {
     
231.           led_1(MOD_TR[3]);
     
232.         led_2(MOD_TR[3]);
     
233.         led_3(MOD_TR[3]);
     
234. }                           
     
235. void led_mod4(void)
     
236.   {
     
237.    switch(num)
     
238.     {
     
239.           case 0:
     
240.             { led1=1;
     
241.                  led2=1;
     
242.                  led3=1;
     
243.                  break;
     
244.                  }
     
245.           case 1:
     
246.              {
     
247.                  led1=0;
     
248.                  led2=1;
     
249.                  led3=1;
     
250.                  break;
     
251.                  }
     
252.           case 2:
     
253.              {
     
254.                  led1=1;
     
255.                  led2=0;
     
256.                  led3=1;
     
257.                  break;
     
258.                  }
     
259.           case 3:
     
260.              {
     
261.                  led1=1;
     
262.                  led2=1;
     
263.                  led3=0;
     
264.                  break;
     
265.                  }
     
266.           case 4:
     
267.              {
     
268.                  led1=1;
     
269.                  led2=0;
     
270.                  led3=0;
     
271.                  break;
     
272.                  }
     
273.           case 5:
     
274.              {
     
275.                  led1=0;
     
276.                  led2=0;
     
277.                  led3=1;
     
278.                  break;
     
279.                  }
     
280.           case 6:
     
281.              {
     
282.                  led1=0;
     
283.                  led2=1;
     
284.                  led3=0;
     
285.                  break;
     
286.                  }
     
287.         }
     
288.   }
     
289. 
     
290. void led_rem(void)
     
291. {
     
292. 
     
293. }
     
294. /*************************************/
     
295. 
     
296. /**************中断设置及执行*****************/
     
297. 
     
298. void InitTimer0(void)                                         //100us
     
299. {
     
300.     TMOD |= 0x02;
     
301.     TH0 = 0x00;
     
302.     TL0 = 0x38;
     
303.     EA = 1;
     
304.     ET0 = 1;
     
305.     TR0 = 1;
     
306. }
     
307.    
     
308. void Timer0Interrupt(void) interrupt 1
     
309. {
     
310.          //add your code here!
     
311.         //disp();
     
312.         t++;
     
313.   if(t==30)
     
314.          {
     
315.           t=0;
     
316.           TN++;
     
317.           if(TN==5) TN=1;
     
318.           dis();
     
319.          }
     
320.   if(t<15)
     
321.     {
     
322.           voice_ctr();
     
323.         }
     
324.    //dis();
     
325. }
     
326. /************************************************/
     
327. void InitTimer1(void)
     
328. {
     
329.     TMOD |= 0x10;
     
330.     TH1 = 0x0B1;
     
331.     TL1 = 0x0E0;
     
332.     EA = 1;
     
333.     ET1 = 1;
     
334.     TR1 = 1;
     
335. }
     
336. 
     
337. void Timer1Interrupt(void) interrupt 3
     
338. {
     
339.     TH1 = 0x0B1;
     
340.     TL1 = 0x0E0;
     
341. /*********add your code here!*****************/
     
342.    //dis();
     
343.   key_fun();
     
344. }
     
345. 
     
346. /*****************按键功能函数************************************/
     
347. void key1_fun(void)                            //按键1功能--模式选择
     
348. {
     
349.    if(!key1)
     
350.           {
     
351.             delayus(1000);
     
352.                  if(!key1)
     
353.                   {
     
354.                    while(!key1);
     
355.                     MOD_NUM++;
     
356.                 if(MOD_NUM==6) MOD_NUM=0;
     
357.                   }
     
358.                   num=0;
     
359.           }
     
360. }
     
361. 
     
362. void key2_fun(void)                           //按键2功能--加
     
363. {
     
364.          if(!key2)
     
365.           {
     
366.             delayus(1000);
     
367.                  if(!key2)
     
368.                   {
     
369.                    while(!key2);
     
370.                   //if(MOD_NUM==0)
     
371.                          {
     
372.                           if(MOD_T_ADDR[MOD_NUM]==99)  MOD_T_ADDR[MOD_NUM]=0;
     
373.                           else MOD_T_ADDR[MOD_NUM]+=1;
     
374.                          }
     
375.                   }
     
376.           }
     
377.     MOD_TR[MOD_NUM]=2*(6000-55*(MOD_T_ADDR[MOD_NUM]+1));        
     
378. }
     
379. 
     
380. void key3_fun(void)                                       //按键3功能--减
     
381. {
     
382.          if(!key3)
     
383.           {
     
384.             delayus(1000);
     
385.                  if(!key3)
     
386.                   {
     
387.                    while(!key3);
     
388.                    if(MOD_T_ADDR[MOD_NUM]==0)  MOD_T_ADDR[MOD_NUM]=99;
     
389.                    else MOD_T_ADDR[MOD_NUM]-=1;
     
390.                   }
     
391.           }
     
392.      MOD_TR[MOD_NUM]=2*(6000-55*(MOD_T_ADDR[MOD_NUM]+1));           
     
393. }
     
394. void key4_fun(void)                                 //存储键：模式，闪烁快慢存储
     
395. {
     
396.          if(!key4)
     
397.           {
     
398.             delayus(1000);
     
399.                  if(!key4)
     
400.                   {
     
401.                    while(!key4);
     
402.                     MOD_NUM_REM=MOD_NUM;
     
403.                         MOD_T_ADD_REM=MOD_T_ADDR[MOD_NUM];
     
404.                   }
     
405.           }
     
406. }
     
407. 
     
408. void key_fun(void)
     
409. {                                                                                                
     
410.   // if(!key1||!key2||!key3||!key4)         key_flag=1;
     
411.    //if(key_flag)
     
412.           key1_fun();
     
413.           key2_fun();
     
414.           key3_fun();        
     
415.           key4_fun();
     
416.          
     
417. }
     
418. //-------------------------------------------------//
     
419. void voice_ctr(void)
     
420. {
     
421.          if(!voice)
     
422.          {
     
423.            //delayus(10);
     
424.            while(!voice);
     
425.            num++;
     
426.            if(num==7) num=0;
     
427.          }
     
428. }
     
429. /**************led花样闪烁*****************/
     
430. void led_work(void)
     
431.    {
     
432.                                                      
     
433.     if(MOD_NUM==0)            { led_mod0(); }
     
434.         else if(MOD_NUM==1)        { led_mod1(); }
     
435.         else if(MOD_NUM==2) { led_mod2(); }
     
436.         else if(MOD_NUM==3) { led_mod3(); }
     
437.         else if(MOD_NUM==4) { led_mod4(); }
     
438.         else
     
439.              {
     
440.                  led1=1;
     
441.              led2=1;
     
442.                  led3=1;
     
443.                  }
     
444.    }
     
445. /*****************************显示函数:模式和闪烁快慢显示***************************/
     
446. void dis(void)
     
447. {
     
448.   /*P0=led_tab[MOD_NUM/10]; seg1           delayus(50);
     
449.   P0=led_tab[MOD_NUM%10]; seg2           delayus(50);
     
450.   P0=led_tab[MOD_T_ADD/10]; seg3               delayus(50);
     
451.   P0=led_tab[MOD_T_ADD%10]; seg4               delayus(50);
     
452.   */                                                                                          
     
453.               if(TN==1)
     
454.                     {
     
455.                          led_disp(1,led_mod[MOD_NUM*2]);
     
456.                          //delayus(5);
     
457.                          }
     
458.                   else if(TN==2)
     
459.                         {
     
460.                         led_disp(2,led_mod[MOD_NUM*2+1]);
     
461.                         //delay_nms(5);
     
462.                 //        delayus(5);
     
463.                         }
     
464.                   else if(TN==3)
     
465.                     {
     
466.                         led_disp(3,led_tab[MOD_T_ADDR[MOD_NUM]/10]);
     
467.                         //delay_nms(5);
     
468.                 //        delayus(5);
     
469.                         }
     
470.                   else
     
471.                     {
     
472.                         led_disp(4,led_tab[MOD_T_ADDR[MOD_NUM]%10]);
     
473.                         //delay_nms(5);
     
474.                 //        delayus(5);
     
475.                         }
     
476. 
     
477.        /*   if(TN==0)
     
478.                     { led_disp(0,led_mod[MOD_NUM*2]);        }
     
479.                   else if(TN==1)
     
480.                         { led_disp(1,led_mod[MOD_NUM*2+1]);        }
     
481.                   else if(TN==2)
     
482.                     {led_disp(2,led_tab[MOD_T_ADD/10]);}
     
483.                   else
     
484.                     {led_disp(3,led_tab[MOD_T_ADD%10]);}
     
485.                         */
     
486.                         
     
487.     /*if(MOD_NUM==0)
     
488.              {
     
489.                   if(TN==0)
     
490.                     { led_disp(0,led_mod[0]);        }
     
491.                   else if(TN==1)
     
492.                         { led_disp(1,led_mod[1]);        }
     
493.                   else if(TN==2)
     
494.                     {led_disp(2,led_tab[MOD_T_ADD0/10]);}
     
495.                   else
     
496.                     {led_disp(3,led_tab[MOD_T_ADD0%10]);}
     
497.                  }
     
498.           else if(MOD_NUM==1)
     
499.              {
     
500.                   if(TN==0)
     
501.                     { led_disp(0,led_mod[2]);        }
     
502.                   else if(TN==1)
     
503.                         { led_disp(1,led_mod[3]);        }
     
504.                   else if(TN==2)
     
505.                     {led_disp(2,led_tab[MOD_T_ADD1/10]);}
     
506.                   else
     
507.                     {led_disp(3,led_tab[MOD_T_ADD1%10]);}
     
508.                  }
     
509.         else if(MOD_NUM==2)
     
510.              {
     
511.                   if(TN==0)
     
512.                     { led_disp(0,led_mod[4]);        }
     
513.                   else if(TN==1)
     
514.                         { led_disp(1,led_mod[5]);        }
     
515.                   else if(TN==2)
     
516.                     {led_disp(2,led_tab[MOD_T_ADD2/10]);}
     
517.                   else
     
518.                     {led_disp(3,led_tab[MOD_T_ADD2%10]);}
     
519.                  }
     
520.         else if(MOD_NUM==3)
     
521.              {
     
522.                   if(TN==0)
     
523.                     { led_disp(0,led_mod[6]);        }
     
524.                   else if(TN==1)
     
525.                         { led_disp(1,led_mod[7]);        }
     
526.                   else if(TN==2)
     
527.                     {led_disp(2,led_tab[MOD_T_ADD3/10]);}
     
528.                   else
     
529.                     {led_disp(3,led_tab[MOD_T_ADD3%10]);}
     
530.                  }
     
531.         else if(MOD_NUM==4)
     
532.              {
     
533.                   if(TN==0)
     
534.                     { led_disp(0,led_mod[8]);        }
     
535.                   else if(TN==1)
     
536.                         { led_disp(1,led_mod[9]);        }
     
537.                   else if(TN==2)
     
538.                     {led_disp(2,led_tab[MOD_T_ADD4/10]);}
     
539.                   else
     
540.                     {led_disp(3,led_tab[MOD_T_ADD4%10]);}
     
541.                  }
     
542.         else
     
543.              {
     
544.                   if(TN==0)
     
545.                     { led_disp(0,led_mod[10]);        }
     
546.                   else if(TN==1)
     
547.                         { led_disp(1,led_mod[11]);        }
     
548.                   else if(TN==2)
     
549.                     {led_disp(2,led_tab[MOD_T_ADD5/10]);}
     
550.                   else
     
551.                     {led_disp(3,led_tab[MOD_T_ADD5%10]);}
     
552.                  }
     
553.         */        
     
554. }
     
555. void dis1(void)
     
556. {
     
557.     /*
     
558.         led_disp(1,led_tab[11]);
     
559.         led_disp(2,led_tab[11]);
     
560.         led_disp(3,led_tab[0]);
     
561.         led_disp(4,led_tab[0]);         delay_led(500);
     
562.         */
     
563.   if(TN==1)
     
564.    {
     
565.     led_disp(1,led_mod[MOD_NUM*2]);                delay_led(35);
     
566.         led_disp(2,led_mod[MOD_NUM*2+1]);        delay_led(35);
     
567.         led_disp(3,led_tab[MOD_T_ADDR[MOD_NUM]/10]); delay_led(35);
     
568.         led_disp(4,led_tab[MOD_T_ADDR[MOD_NUM]%10]); delay_led(35);
     
569.    }
     
570.   else if(TN==2)
     
571.    {
     
572.     led_disp(2,led_mod[MOD_NUM*2+1]);         delay_led(35);
     
573.         led_disp(3,led_tab[MOD_T_ADDR[MOD_NUM]/10]);  delay_led(35);
     
574.         led_disp(4,led_tab[MOD_T_ADDR[MOD_NUM]%10]);  delay_led(35);
     
575.         led_disp(1,led_mod[MOD_NUM*2]);                                  delay_led(35);
     
576.    }
     
577.   else if(TN==3)
     
578.    {
     
579.     led_disp(3,led_tab[MOD_T_ADDR[MOD_NUM]/10]);  delay_led(35);
     
580.         led_disp(4,led_tab[MOD_T_ADDR[MOD_NUM]%10]);  delay_led(35);
     
581.         led_disp(1,led_mod[MOD_NUM*2]);                                   delay_led(35);
     
582.         led_disp(2,led_mod[MOD_NUM*2+1]);                         delay_led(35);
     
583.         }
     
584.   else if(TN==4)
     
585.    {
     
586.     led_disp(4,led_tab[MOD_T_ADDR[MOD_NUM]%10]);        delay_led(35);
     
587.         led_disp(1,led_mod[MOD_NUM*2]);                                        delay_led(35);
     
588.         led_disp(2,led_mod[MOD_NUM*2+1]);                                delay_led(35);
     
589.         led_disp(3,led_tab[MOD_T_ADDR[MOD_NUM]/10]);        delay_led(35);
     
590.    }
     
591. }
     
592. void disp(void)
     
593. {
     
594.                    P0=led_tab[11]; P2=0x20;                // P0=0x0f;  //led_tab[11];
     
595.                    delayus(14);
     
596.                    //P2=0xff;
     
597.                    //delayms(10);
     
598.                   
     
599.                    P0=led_tab[11]; P2=0x10;                 //P0=0x0f;  //led_tab[11];
     
600.                    delayus(14);
     
601.                    //P2=0x00;                  
     
602.                    //P2=0xff;
     
603.                    //delayms(10);
     
604.                  
     
605.                    P0=led_tab[0]; P2=0x08;         // P0=0x0a;  //led_tab[0];
     
606.                    delayus(14);
     
607.                    //P2=0x00;               
     
608.                    //P2=0xff;
     
609.                    //delayms(10);
     
610.                   
     
611.                     P0=led_tab[0]; P2=0x40;          //P0=0x0a;  //led_tab[0];
     
612.                     delayus(14);        
     
613.                         //P2=0x00;        
     
614.                    //P2=0xff;
     
615.                    //delayms(10);
     
616. }        
     

复制代码

---

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

Powered by Discuz! X3.1