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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 单片机ws2812程序无法用按键控制?
返回列表 发新帖
查看: 699|回复: 2
收起左侧

单片机ws2812程序无法用按键控制?

[复制链接]
ID:190152 发表于 2024-1-2 12:22 | 显示全部楼层 |阅读模式
这个是用别人的程序修改的，现在遇到几个问题。外部中断接的开机按键需要按几次才能开机。按键左和按键右无法控制切换流水灯模式

单片机源程序如下:
  1. #include<STC8Hxxx.h>
  2. #include"intrins.h"

  4. sbit WS2812 = P3^2;
  5. sbit Power= P1^0;//ws2812电源开关
  6. sbit key_left= P2^0;//按键左
  7. sbit key_right= P2^1;//按键右
  8. sbit key_ok= P2^2;//按键确认
  9. sbit key_Return= P2^3;//按键返回



  13. #define numLEDs 64  //灯的个数

  15. unsigned char buf_R[numLEDs] = {0};//颜色缓存
  16. unsigned char buf_G[numLEDs] = {0};
  17. unsigned char buf_B[numLEDs] = {0};
  18. unsigned char Timer0_cnt=0;//记录定时器0中断次数
  19. unsigned char list=1;//播放列表

  21. void RGB_Set_Up();  //送0码
  22. void RGB_Set_Down(); //送1码
  23. void Timer0_Init();//按键扫描定时器0初始化
  24. void key_service();//按键服务程序
  25. //void playlist(unsigned char list);



  29. //真对 STC8系列 IO口初始化 准双向
  30. void IO_init(void)
  31. {

  33.   P0M0 = 0X00;
  34.   P0M1 = 0X00;

  36.   P1M0 = 0X01;
  37.   P1M1 = 0X00;

  39.   P2M0 = 0X00;
  40.   P2M1 = 0X00;

  42.   P3M0 = 0X00;
  43.   P3M1 = 0X00;

  45.   P4M0 = 0X00;
  46.   P4M1 = 0X00;

  48.   P5M0 = 0X00;
  49.   P5M1 = 0X00;
  50. }


  53. void HAL_Delay(unsigned long t)
  54. {
  55.                   unsigned int x,y;
  56.                   for(x=114;x>0;x--)
  57.           for(y=t;y>0;y--);
  58. }

  60.    //复位延时
  61. void Delay50us()                //@22.1184MHz
  62. {
  63.         unsigned char i, j;

  65.         _nop_();
  66.         _nop_();
  67.         i = 2;
  68.         j = 15;
  69.         do
  70.         {
  71.                 while (--j);
  72.         } while (--i);
  73. }
  74. //1码，高电平850ns 低电平400ns 误差正负150ns
  75. void RGB_Set_Up()
  76. {
  77.                 WS2812 = 1;
  78.           //经过逻辑分析仪调试的的延时
  79.                 _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_();
  80.           _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_();
  81.                 WS2812 = 0;
  82. }
  83. //1码，高电平400ns 低电平850ns 误差正负150ns
  84. void RGB_Set_Down()
  85. {
  86.    WS2812 = 1;
  87.           //经过逻辑分析仪调试的的延时
  88.                 _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_();  
  89.                 WS2812 = 0;
  90. }

  92. //发送24位数据
  93. void Send_2812_24bits(unsigned char G8,unsigned char R8,unsigned char B8)
  94. {
  95.                    unsigned int n = 0;
  96.                    //发送G8位
  97.                   for(n=0;n<8;n++)
  98.                   {
  99.                       G8<<=n;
  100.                           if(G8&0x80 == 0x80)
  101.                           {
  102.                              RGB_Set_Up();
  103.                           }
  104.                           else
  105.                           {
  106.                             RGB_Set_Down();
  107.                           }
  108.                   }
  109.                   //发送R8位
  110.                   for(n=0;n<8;n++)
  111.                   {
  112.                       R8<<=n;
  113.                           if(R8&0x80 == 0x80)
  114.                           {
  115.                              RGB_Set_Up();
  116.                           }
  117.                           else
  118.                           {
  119.                             RGB_Set_Down();
  120.                           }
  121.                   }
  122.                         //发送B8位
  123.                     for(n=0;n<8;n++)
  124.                   {
  125.                       B8<<=n;
  126.                           if(B8&0x80 == 0x80)
  127.                           {
  128.                              RGB_Set_Up();
  129.                           }
  130.                           else
  131.                           {
  132.                             RGB_Set_Down();
  133.                            }
  134.                   }
  135.                   
  136.                   
  137.          
  138. }                 
  139. //复位码
  140. void RGB_Rst()
  141. {
  142.             WS2812 = 0;
  143.           Delay50us();
  144. }

  146. //颜色交换24位不拆分发

  148. void SetPixelColor(unsigned char num,unsigned long c)
  149. {
  150.            unsigned char i;
  151.        for(i=0;i<numLEDs;i++)
  152.            {
  153.               buf_R[num] = (unsigned char)(c>>16);
  154.                           buf_G[num] = (unsigned char)(c>>8);
  155.                           buf_B[num] = (unsigned char)(c);
  156.            }

  158.                  for(i=0;i<numLEDs;i++)
  159.                 {
  160.                         Send_2812_24bits(buf_G[i],buf_R[i],buf_B[i]);
  161.                 }

  163. }

  165. //复位
  166. void PixelUpdate()
  167. {
  168.         RGB_Rst();
  169. }


  172. // Fill the dots one after the other with a color
  173. //用一种颜色填充这些圆点
  174. void colorWipe(unsigned long c, unsigned int wait)
  175. {
  176.   unsigned char i=0;
  177.   for( i=0; i<numLEDs; i++)
  178.         {
  179.     SetPixelColor(i, c);
  180.     PixelUpdate();
  181.     HAL_Delay(wait*5);
  182.   }

  184. }
  185. void Watercolor(unsigned long c, unsigned int wait)
  186. {
  187.   unsigned char i=0;
  188.   for( i=0; i<numLEDs; i++)
  189.         {
  190.     SetPixelColor(i, c);
  191.          PixelUpdate();
  192.     HAL_Delay(wait*5);
  193.         SetPixelColor(i, 0);
  194.    PixelUpdate();
  195.     HAL_Delay(wait);
  196.   }

  198. }

  200. //颜色
  201. unsigned long Color(unsigned char r, unsigned char g, unsigned char b)
  202. {
  203.   return ((unsigned long)r << 16) | ((unsigned long)g <<  8) | b;
  204. }

  206. //颜色算法
  207. unsigned long Wheel(unsigned char WheelPos)
  208. {
  209.   WheelPos = 255 - WheelPos;
  210.   if(WheelPos < 85)
  211.         {
  212.     return Color(255 - WheelPos * 3, 0, WheelPos * 3);
  213.   }
  214.   if(WheelPos < 170) {
  215.     WheelPos -= 85;
  216.     return Color(0, WheelPos * 3, 255 - WheelPos * 3);
  217.   }
  218.   WheelPos -= 170;
  219.   return Color(WheelPos * 3, 255 - WheelPos * 3, 0);
  220. }

  222. //彩虹
  223. void rainbow(unsigned int wait)
  224. {
  225.   unsigned int i, j;

  227.   for(j=0; j<256; j++)
  228.         {
  229.             for(i=0; i<numLEDs; i++)
  230.                 {
  231.                                       SetPixelColor(i, Wheel((i+j) & 255));
  232.                             }
  233.                 PixelUpdate();
  234.                             HAL_Delay(wait);
  235.                   }
  236. }

  238. //稍微不同的是，这使得彩虹均匀分布
  239. void rainbowCycle(unsigned int wait)
  240. {
  241.   unsigned int i, j;

  243.   for(j=0;j<256*5;j++)
  244.         { // 5 cycles of all colors on wheel  车轮上所有颜色的5个循环
  245.     for(i=0;i<numLEDs;i++)
  246.          {
  247.      SetPixelColor(i, Wheel(((i * 256 / numLEDs) + j) & 255));
  248.     }
  249.           PixelUpdate();
  250.     HAL_Delay (wait);
  251.   }
  252. }


  255. //Theatre-style crawling lights with rainbow effect
  256. //带有彩虹效果的戏剧式爬行灯
  257. void theaterChaseRainbow(unsigned int wait)
  258. {
  259.         int j,q;
  260.         unsigned int i;
  261.   for (j=0; j < 256; j++)
  262.         {     // cycle all 256 colors in the wheel 在轮子上循环所有256色
  263.     for (q=0; q < 3; q++)
  264.                 {
  265.       for (i=0; i < numLEDs; i=i+3)
  266.                         {
  267.         SetPixelColor(i+q, Wheel( (i+j) % 255));    //turn every third pixel off 把每一个第三个像素
  268.       }
  269.       PixelUpdate();

  271.       HAL_Delay(wait);

  273.       for (i=0; i < numLEDs; i=i+3)
  274.                         {
  275.         SetPixelColor(i+q, 0);        //turn every third pixel off  把每一个第三个像素关掉
  276.       }
  277.     }
  278.   }
  279. }

  281. void colorWipe_1()//颜色刷1
  282.         {
  283.                                     colorWipe(0xff0000,1);        //红色
  284.                                          HAL_Delay(10000);
  285.                                    colorWipe(0xff00,1);         //绿色
  286.                                         HAL_Delay(10000);
  287.                                    colorWipe(0xff,1);//蓝色
  288.                                         HAL_Delay(10000);
  289.                                    colorWipe(0xffff00,1);        //黄色
  290.                                          HAL_Delay(10000);
  291.                                    colorWipe(0xffff,1);        //青色
  292.                                          HAL_Delay(10000);
  293.                                    colorWipe(0xff00ff,1);        //紫色
  294.                                          HAL_Delay(10000);
  295.                                    colorWipe(0xffffff,1);        //白色
  296.                                          HAL_Delay(10000);
  297.                                    colorWipe(0x00,1);        //off
  298.                                          HAL_Delay(10000);
  299.         }

  301. void colorWipe_2()//颜色刷2
  302.         {
  303.                             Watercolor(0xff0000, 100);//红色
  304.                                          HAL_Delay(1000);
  305.                                         Watercolor(0xff00, 100);//绿色
  306.                                          HAL_Delay(1000);
  307.                                         Watercolor(0xff, 100);//蓝色
  308.                                          HAL_Delay(1000);
  309.                                         Watercolor(0xffff00, 100);        //黄色
  310.                                          HAL_Delay(1000);
  311.                                         Watercolor(0xffff, 100);//青色
  312.                                          HAL_Delay(1000);
  313.                                         Watercolor(0xff00ff, 100);        //紫色
  314.                                          HAL_Delay(1000);
  315.                                         Watercolor(0xffffff, 100);        //白色
  316.                                          HAL_Delay(1000);        
  317.                                         colorWipe(0x00,1);        //off
  318.                                          HAL_Delay(10000);
  319.         }

  321. void colorWipe_3()//颜色刷3
  322.         {
  323.                                          colorWipe(0xff0000,100);        //红色
  324.                                          HAL_Delay(1000);
  325.                                         colorWipe(0x00,100);        //0ff
  326.                                          HAL_Delay(1000);
  327.                                         colorWipe(0xff00,100);         //绿色
  328.                                          HAL_Delay(1000);
  329.                                         colorWipe(0x00,100);        //0ff
  330.                                          HAL_Delay(1000);
  331.                                         colorWipe(0xff,100);//蓝色
  332.                                          HAL_Delay(1000);
  333.                                     colorWipe(0x00,100);        //0ff
  334.                                          HAL_Delay(1000);
  335.                                     colorWipe(0xffff00,100);        //黄色
  336.                                          HAL_Delay(1000);
  337.                                         colorWipe(0x00,100);        //0ff
  338.                                          HAL_Delay(1000);
  339.                                         colorWipe(0xffff,100);        //青色
  340.                                          HAL_Delay(1000);
  341.                                         colorWipe(0x00,100);        //0ff
  342.                                          HAL_Delay(1000);
  343.                                         colorWipe(0xff00ff,100);        //紫色
  344.                                          HAL_Delay(1000);
  345.                                          colorWipe(0x00,100);        //0ff
  346.                                          HAL_Delay(1000);
  347.                                            colorWipe(0xffffff,100);        //白色
  348.                                          HAL_Delay(1000);
  349.                                         colorWipe(0x00,100);        //0ff
  350.                                           HAL_Delay(1000);
  351.         }


  354. void main()
  355. {               
  356.                 IO_init();        //io口初始化
  357.                 IT1 = 1; //设置INT1的中断类型 (1:仅下降沿 0:上升沿和下降沿)
  358.                 EX1 = 1;//使能INT1中断
  359.                 INTCLKO|=0x10;//开启外部中断2
  360.             EA = 1;                //开启总中断
  361.                 Timer0_Init();//按键扫描定时器0初始化
  362.                 while(1)
  363.                 {        
  364.                 key_service();//按键服务程序  
  365.                 switch(list)
  366.                                 {
  367.                                 case 1: colorWipe_1(); break;//颜色刷1
  368.                                 case 2: colorWipe_2(); break;//颜色刷2
  369.                                 case 3: colorWipe_3(); break;//颜色刷3
  370.                                 case 4: rainbow(10); break;//彩虹
  371.                                 case 5: rainbowCycle(10); break;//彩虹2
  372.                                 case 6:        theaterChaseRainbow(10); break;//彩虹升级
  373.                                 default:break;
  374.                                 }                 
  375.                
  376.            
  377.                 }
  378. }

  380. //-----------------------------------------
  381. //按键定时器初始化程序
  382. void Timer0_Init(void)                //20毫秒@22.1184MHz
  383. {
  384.         AUXR &= 0x7F;                        //定时器时钟12T模式
  385.         TMOD &= 0xF0;                        //设置定时器模式
  386.         TMOD |= 0x01;                        //设置定时器模式16位模式
  387.         TL0 = 0x00;                                //设置定时初始值
  388.         TH0 = 0x70;                                //设置定时初始值
  389.         TF0 = 0;                                //清除TF0标志
  390.         //ET0 = 1;                //定时器0中断开启
  391.         TR0 = 1;                                //定时器0开始计时
  392. }

  394. void Delay10ms()                //@22.1184MHz 按键消抖10ms延时
  395. {
  396.         unsigned char i, j, k;

  398.         i = 2;
  399.         j = 32;
  400.         k = 60;
  401.         do
  402.         {
  403.                 do
  404.                 {
  405.                         while (--k);
  406.                 } while (--j);
  407.         } while (--i);
  408. }


  411. //按键扫描服务程序
  412. void key_service()//按键服务程序
  413.         {
  414.         if(TF0==1)
  415.                 {
  416.                          TF0 = 0;                                //清除TF0标志
  417.                         TL0 = 0x9A;                                //设置定时初始值
  418.                         TH0 = 0xA9;                                //设置定时初始值

  420.                         if(key_Return==0)//返回键扫描
  421.                                 {
  422.                                  Delay10ms();                //按键消抖延时@22.1184MHz
  423.                                  if(key_Return==1)
  424.                                          {
  425.                                                 RGB_Rst();//复位
  426.                                                 colorWipe(0xffffff,100);        //白色
  427.                                                  PCON=0x02;//进入掉电模式
  428.                                                  _nop_();
  429.                                                     _nop_();
  430.                                         }
  431.                                         while(!key_Return);//等待按键松开
  432.                                 }

  434.                         if(key_ok == 0)//OK键扫描
  435.                                  {
  436.                                         Delay10ms();                //按键消抖延时@22.1184MHz
  437.                                         if(key_ok==0)
  438.                                                 {
  439.                                                         RGB_Rst();//复位
  440.                                                         colorWipe(0xffff00,100);        //黄色
  441.                                                         PCON=0x02;//进入掉电模式
  442.                                                          _nop_();
  443.                                                             _nop_();
  444.                                                 }
  445.                                 while(!key_ok);//等待按键松开
  446.                                 }

  448.                         if( key_left == 0)//按键左键扫描
  449.                                  {
  450.                                         Delay10ms();                //按键消抖延时@22.1184MHz
  451.                                         if(key_left==0)
  452.                                                 {
  453.                                                 RGB_Rst();//复位
  454.                                                 list--;
  455.                                                 }
  456.                                 while(!key_left);//等待按键松开
  457.                                 }
  458.                         if(key_right == 0)//按键右键扫描
  459.                                  {
  460.                                         Delay10ms();                //按键消抖延时@22.1184MHz
  461.                                         if(key_right==0)
  462.                                                 {
  463.                                                 RGB_Rst();//复位
  464.                                                 list++;
  465.                                                 }
  466.                                 while(!key_right);//等待按键松开
  467.                                 }
  468.                                        
  469.                 }
  470.         }


  473. //中断服务程序
  474. void exint0() interrupt 2       //INT1中断入口
  475. {
  476.         colorWipe(0x00,100);        //0ff
  477.         Power = 0;        //关闭ws2812电源
  478.     P3M0 = 0x00; P3M1 = 0x04;//P3.2高阻输入
  479.         PCON=0x02;//进入掉电模式
  480.         _nop_();
  481.     _nop_();
  482. }


  485. //-----------------------------------------
  486. //中断服务程序
  487. void exint1() interrupt 10      //INT2中断入口
  488. {
  489.     EA = 0;                //关闭总中断
  490.         PCON=0x00;//取消掉电模式
  491.         P3M0 = 0x00; P3M1 = 0x00;//P3.2准双向输入
  492.         Power = 1;        //开启ws2812电源
  493.           EA = 1;                //开启总中断
  494.         _nop_();
  495.     _nop_();
  496. }

复制代码
回复

使用道具 举报

ID:161164 发表于 2024-1-2 16:05 | 显示全部楼层
按键左和按键右无法控制切换流水灯模式是因为其他地方用了大量长时间delay
全部时间都耗在颜色刷函数里
阻塞了按键扫描函数
放弃delay(10000)吧
给你一个思路
  1. #include <reg52.h>
  2. typedef         unsigned char        u8;  //0 to 255
  3. typedef         unsigned int        u16;  //0 to 65535
  4. sbit Led = P1^0;
  5. void Delay1ms(void)        //@11.0592MHz
  6. {
  7.         unsigned char data i, j;

  9.         i = 2;
  10.         j = 199;
  11.         do
  12.         {
  13.                 while (--j);
  14.         } while (--i);
  15. }
  16. u16 Delay = 0;
  17. void main()
  18. {
  19.         P1 = 0xFE;
  20.     while (1)
  21.     {
  22.                 if(++Delay>=500)
  23.                 {
  24.                         Delay = 0;
  25.                         Led = !Led;
  26.                 }
  27.                 Delay1ms();
  28.     }
  29. }
复制代码
回复

使用道具 举报

ID:190152 发表于 2024-1-2 21:20 | 显示全部楼层
lkc8210 发表于 2024-1-2 16:05
按键左和按键右无法控制切换流水灯模式是因为其他地方用了大量长时间delay
全部时间都耗在颜色刷函数里
...

感谢热情指导，有空去掉延时函数试试。我试过用定时器中断10ms扫描按键但是流水的会闪烁。或者用两个定时器中断一个负责刷新一个负责按键。
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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