设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 单片机舞台灯程序 含有源码 我一直收藏的
返回列表 发新帖
查看: 2403|回复: 0
打印 上一主题 下一主题
收起左侧

单片机舞台灯程序 含有源码 我一直收藏的

[复制链接]
跳转到指定楼层
楼主
ID:191780 发表于 2017-4-20 20:01 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
我收藏的舞台灯程序 含有源码

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


单片机源码：
  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. */

  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;         //声控引脚

  23. /***********延时函数*******************/                                       
  24. void delay(unsigned int time);
  25. void delayus(uint t);
  26. void delayms(uint k);

  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);

  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,声控模式

  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);

  54. /******************************/
  55. void led_work(void);    //led 花样闪烁
  56. void led_rem(void);                   //记忆模式功能，开机时执行
  57. void voice_ctr(void);        //声控功能

  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;

  76. //code uchar led_mod[]={0x39,0x39,0x39,0x73,0x39,0x6d,0x5e,0x79,0x7c,0x79,0x5e,0x3f};          //89板模式数显段

  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();

  86.         led1=0;
  87.         led2=0;
  88.         led3=0;
  89.         P2=0x00;        //数码管初始化控制

  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;        


  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;


  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. }


  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. }

  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. /************************************/

  158. void led_1(uint t)
  159. {
  160.           led1=1;
  161.           delayms(t);  
  162.           led1=0;
  163.           delayms(t);  
  164.          

  166.           led2=1;
  167.           delayms(t);  
  168.           led2=0;
  169.           delayms(t);  

  171.           led3=1;
  172.           delayms(t);
  173.           led3=0;
  174.           delayms(t);
  175. }

  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.          

  187.           led2=1;
  188.           led3=1;
  189.           delayms(t);  
  190.           led2=0;
  191.           led3=0;
  192.           delayms(t);

  194.           led3=1;
  195.           led1=1;
  196.           delayms(t);
  197.           led3=0;
  198.           led1=0;
  199.           delayms(t);  

  201. }

  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. }

  219. void led_mod1(void)
  220. {
  221. led_2(MOD_TR[1]);
  222. }

  224. void led_mod2(void)
  225. {
  226. led_3(MOD_TR[2]);
  227. }

  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.   }

  290. void led_rem(void)
  291. {

  293. }
  294. /*************************************/

  296. /**************中断设置及执行*****************/

  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. }

  337. void Timer1Interrupt(void) interrupt 3
  338. {
  339.     TH1 = 0x0B1;
  340.     TL1 = 0x0E0;
  341. /*********add your code here!*****************/
  342.    //dis();
  343.   key_fun();
  344. }

  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. }

  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. }

  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. }

  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.                         }

  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. }        
复制代码


舞台灯, 程序
分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏3 分享淘帖 顶顶 踩踩1

相关帖子
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表