找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 1015|回复: 1
打印 上一主题 下一主题
收起左侧

基于51单片机·的·led灯控制

[复制链接]
跳转到指定楼层
楼主
ID:467471 发表于 2019-5-27 23:53 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
基于51单片机的led灯控制,

单片机源程序如下:
  1. /*
  2. *  @file:      led灯控制器.c
  3. *  @function:  控制led   
  4. *  @date:      2019.5.22
  5. *  @version:   v1.0
  6. *  @author:    xiaohuli
  7. */
  8. #include<reg51.h>
  9. sbit key2=P3^0;                 //定义独立按键端口
  10. sbit key3=P3^2;
  11. sbit key1=P3^1;
  12. sbit key4=P3^3;

  13. unsigned char led2[]={
  14. 0x7f,0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf};        //定义led向右移动

  15. unsigned char led1[]={
  16. 0xfe,0x7f,0xbf,0xdf,0xef,0xf7,0xfb,0xfd};        //定义led向左移动

  17. unsigned char led3[]={
  18. 0xf7,0xe7,0xe3,0xc3,0xc1,0x81,0x80,0x00};        // 模式2led

  19. unsigned char led4[]={
  20. 0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};        //        模式3led

  21. unsigned char led5[]={
  22. 0xfe,0xdf,0xfb,0x7f,0xef,0xfd,0xbf,0xf7};  //        模式3led

  23. /*
  24. *  @file:      delay(unsigned int z)
  25. *  @function:  延时   
  26. *  @date:      2019.5.22
  27. *  @version:   v1.0
  28. *  @author:    xiaohuli
  29. */
  30. void delay(unsigned int z)
  31. {
  32.      unsigned int y;
  33.      for(;z>0;z--)
  34.          for(y=10;y>0;y--);
  35. }

  36. /*
  37. *  @file:      Timer0Init()
  38. *  @function:  定时器初始化   
  39. *  @date:      2019.5.22
  40. *  @version:   v1.0
  41. *  @author:    xiaohuli
  42. */
  43. void Timer0Init()
  44. {
  45.         TMOD|=0X01;//选择为定时器0模式,工作方式1,仅用TR0打开启动。

  46.         TH0=0XFC;        //给定时器赋初值,定时1ms
  47.         TL0=0X18;       
  48.         ET0=1;//打开定时器0中断允许
  49.         EA=1;//打开总中断
  50.         TR0=1;//打开定时器                       
  51. }

  52. /*
  53. *  @file:      interface()
  54. *  @function:  初始界面  
  55. *  @date:      2019.5.22
  56. *  @version:   v1.0
  57. *  @author:    xiaohuli
  58. */
  59. void interface()
  60. {
  61.      int i,j;
  62.          for(i=0;i<2;i++)
  63.          {
  64.              for(j=0;j<8;j++)
  65.                  {
  66.                      P2=led1[j];
  67.                          delay(1000);
  68.                  }
  69.          }
  70.          i=0;                   //将ij置0,方便下一次循环
  71.          j=0;
  72.          for(i=0;i<2;i++)
  73.          {
  74.              for(j=0;j<8;j++)
  75.                  {
  76.                      P2=led2[j];
  77.                          delay(1000);
  78.                  }
  79.          }
  80.          i=0;
  81.          j=0;
  82.          for(i=0;i<5;i++)
  83.          {
  84.              P2=0xaa;
  85.                  delay(2000);
  86.                  P2=0xff;
  87.                  delay(2000);
  88.          }
  89.          for(j=0;j<5;j++)
  90.          {
  91.              P2=0x55;
  92.                  delay(2000);
  93.                  P2=0xff;
  94.                  delay(2000);
  95.          }
  96. }


  97. /*
  98. *  @file:      pattern1()
  99. *  @function:  模式1  
  100. *  @date:      2019.5.22
  101. *  @version:   v1.0
  102. *  @author:    xiaohuli
  103. */
  104. void pattern1()
  105. {
  106.              P2=0xaa;
  107.                  delay(5000);
  108.                  P2=0x55;
  109.                  delay(5000);
  110. }


  111. /*
  112. *  @file:      pattern2()
  113. *  @function:  模式2  
  114. *  @date:      2019.5.22
  115. *  @version:   v1.0
  116. *  @author:    xiaohuli
  117. */
  118. void pattern2()
  119. {
  120.      int i,j;
  121.          for(j=0;j<3;j++)
  122.          {
  123.                  for(i=0;i<8;i++)
  124.                  {
  125.                      P2=led3[i];
  126.                          delay(5000);
  127.                  }
  128.                  if(i==8)
  129.                  {  
  130.                    P2=0xff;
  131.                    delay(5000);
  132.                  }
  133.          }
  134. }


  135. /*
  136. *  @file:      pattern3()
  137. *  @function:  模式3  
  138. *  @date:      2019.5.22
  139. *  @version:   v1.0
  140. *  @author:    xiaohuli
  141. */
  142. void pattern3()
  143. {
  144.      int i,j;
  145.          int flag;        //          定义向左向右的标志变量
  146.          int keyflag; //   定义处理按键按下的标志变量
  147.          int count;          
  148.          if(key3==0)
  149.          {
  150.             delay(10);                  //延时消抖
  151.                 if(key3==0)
  152.                 {
  153.                    keyflag=1;
  154.                    TR0=1;                           //开启定时器
  155.                    while(!key3);
  156.                    TR0=0;                             //关闭定时器
  157.                 }
  158.          }
  159.          if(key4==0)
  160.          {         
  161.             delay(10);
  162.                 if(key4==0)
  163.                 {
  164.                    keyflag=2;
  165.                    TR0=1;
  166.                    while(!key4);
  167.                    TR0=0;  
  168.                 }
  169.          }
  170.          if(keyflag==1)                           //处理按键
  171.          {
  172.             if(count>=1500)                        //长按处理程序
  173.                 {
  174.                     i++;
  175.                    if(i>=4)
  176.                           i=3;
  177.                 }
  178.                 else                                        //短按处理程序
  179.                 {
  180.                      i++;
  181.                    if(i>=4)
  182.                           i=3;
  183.                 }
  184.                 keyflag=0;                        //将标志变量置0;
  185.                 count=0;
  186.           }
  187.           if(keyflag==2)
  188.           {
  189.              if(count>=1500)
  190.                  {
  191.                    flag++;
  192.                    if(flag==2)
  193.                      flag=0;
  194.                  }
  195.                  else
  196.                  {
  197.                           flag++;
  198.                    if(flag==2)
  199.                      flag=0;
  200.                  }
  201.                  keyflag=0;
  202.                  count=0;
  203.           }
  204.          switch(i)                                                         //对i,进行分类处理,判断是左移或右移几位
  205.          {
  206.                case 0:
  207.                          if(flag==0)
  208.                          {
  209.                                  for(j=0;j<8;j++)
  210.                                          {
  211.                                              P2=led4[j];
  212.                                                  delay(5000);
  213.                                          }
  214.                                          j=0;
  215.                                  }
  216.                                  if(flag==1)
  217.                                  {
  218.                                     for(j=0;j<8;j++)
  219.                                          {
  220.                                              P2=led1[j];
  221.                                                  delay(5000);
  222.                                          }
  223.                                          j=0;
  224.                                  }                                 
  225.                              break;
  226.                    case 1:
  227.                          if(flag==0)
  228.                                  {
  229.                                  for(j=0;j<8;j=j+2)
  230.                                          {
  231.                                              P2=led4[j];
  232.                                                  delay(5000);
  233.                                          }
  234.                                          j=0;
  235.                                  }
  236.                                  if(flag==1)
  237.                                  {
  238.                                     for(j=0;j<8;j=j+2)
  239.                                          {
  240.                                              P2=led1[j];
  241.                                                  delay(5000);
  242.                                          }
  243.                                          j=0;
  244.                                  }
  245.                                  break;
  246.                    case 2:                                                                   //这个算法可以直接定义一个一维数组代替
  247.                          if(flag==0)
  248.                                  {
  249.                                  for(j=0;j<22;j=j+3)
  250.                                          {
  251.                                              if(j==9)
  252.                                                  {
  253.                                                     P2=0xfd;
  254.                                                         delay(5000);
  255.                                                  }
  256.                                                  else
  257.                                                  {
  258.                                                     if(j==12)
  259.                                                         {
  260.                                                            P2=0xef;
  261.                                                            delay(5000);
  262.                                                         }
  263.                                                         else
  264.                                                         {
  265.                                                            if(j==15)
  266.                                                            {
  267.                                                               P2=0x7f;
  268.                                                                   delay(5000);
  269.                                                            }
  270.                                                            else
  271.                                                            {
  272.                                                               if(j==18)
  273.                                                                   {
  274.                                                                      P2=0xfb;
  275.                                                                          delay(5000);
  276.                                                                   }
  277.                                                                   else
  278.                                                                   {
  279.                                                                      if(j==21)
  280.                                                                          {
  281.                                                                             P2=0xdf;
  282.                                                                                 delay(5000);
  283.                                                                          }
  284.                                                                          else
  285.                                                                          {
  286.                                                                     P2=led4[j];
  287.                                                                     delay(5000);
  288.                                                                          }
  289.                                                                   }
  290.                                                            }
  291.                                                         }
  292.                                                  }
  293.                                  }
  294.                                          j=0;
  295.                                  }
  296.                                  if(flag==1)
  297.                                  {
  298.                                          for(j=0;j<8;j++)
  299.                                          {
  300.                                             P2=led5[j];
  301.                                                 delay(5000);
  302.                                          }
  303.                                          j=0;
  304.                                  }      
  305.                                  break;
  306.                    case 3:
  307.                          if(flag==0)
  308.                                  {
  309.                                  for(j=0;j<8;j=j+4)
  310.                                          {
  311.                                              P2=led4[j];
  312.                                                  delay(5000);
  313.                                          }
  314.                                          j=0;
  315.                                  }
  316.                                  if(flag==1)
  317.                                  {
  318.                                     for(j=0;j<8;j=j+4)
  319.                                          {
  320.                                              P2=led1[j];
  321.                                                  delay(5000);
  322.                                          }
  323.                                          j=0;
  324.                                  }
  325.                                  break;
  326.                  }
  327. }


  328. /*
  329. *  @file:      主函数
  330. *  @function:  主函数
  331. *  @date:      2019.5.22
  332. *  @version:   v1.0
  333. *  @author:    xiaohuli
  334. */
  335. void main()
  336. {
  337.      Timer0Init();
  338.          interface();
  339.          while(1)
  340.          {
  341.               int keyflag2;
  342.                   int k;
  343.                   int count;
  344.                   if(key1==0)
  345.               {  
  346.                  delay(10);
  347.                      if(key1==0)
  348.                      {
  349.                         keyflag2=1;
  350.                         TR0=1;
  351.                         while(!key1);
  352.                         TR0=0;  
  353.                      }
  354.               }
  355.                   if(key2==0)
  356.               {  
  357.                  delay(10);
  358.                      if(key2==0)
  359.                      {
  360.                         keyflag2=2;
  361.                         TR0=1;
  362.                         while(!key2);
  363.                         TR0=0;  
  364.                      }
  365.               }
  366.                   if(keyflag2==1)
  367.                   {
  368.                             if(count>=1500)
  369.                          {
  370.                              pattern1();
  371.                          }
  372.                          else
  373.                          {
  374.                             pattern1();
  375.                          }
  376.                          //keyflag2=0;                注意,这个标志变量不能置0,否则·不会·无限循环
  377.                          count=0;
  378.                   }
  379.                   if(keyflag2==2)
  380.                   {
  381.                             if(count>=1500)
  382.                          {
  383.                             for(k=0;k<1;k++)
  384.                                 {
  385.                                     pattern2();
  386.                                 }
  387.                                 pattern3();
  388.                          }
  389.                          else
  390.                          {
  391.                             for(k=0;k<1;k++)
  392.                                 {
  393.                                     pattern2();
  394.                                 }
  395.                 for(k=0;k<100;k++)
  396.                                 pattern3();
  397.                          }
  398.                          keyflag2=0;
  399.                          count=0;
  400.                   }
  401.          }
  402. }

  403. /*
  404. *  @file:      Timer0() interrupt 1
  405. *  @function:  定时器0的1模式中断
  406. *  @date:      2019.5.22
  407. *  @version:   v1.0
  408. *  @author:    xiaohuli
  409. */
  410. void Timer0() interrupt 1
  411. {
  412.         static int i;
  413.         TH0=0XFC;        //给定时器赋初值,定时1ms
  414.         TL0=0X18;
  415.         i++;
  416. }         
复制代码

所有资料51hei提供下载:
led灯控制器.zip (27.01 KB, 下载次数: 9)


分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶 踩
回复

使用道具 举报

沙发
ID:1 发表于 2019-5-29 04:53 | 只看该作者
本帖需要重新编辑补全电路原理图,源码,详细说明与图片即可获得100+黑币(帖子下方有编辑按钮)
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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